@bench.games/opportunity-markets 0.3.1 → 0.3.3

package/dist/browser/index.js

@@ -176,28 +176,28 @@ async function fetchAllMaybeArciumSignerAccount(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists3,
   assertAccountsExist as assertAccountsExist3,
-  combineCodec as combineCodec52,
+  combineCodec as combineCodec51,
   decodeAccount as decodeAccount3,
   fetchEncodedAccount as fetchEncodedAccount3,
   fetchEncodedAccounts as fetchEncodedAccounts3,
   fixDecoderSize as fixDecoderSize3,
   fixEncoderSize as fixEncoderSize3,
-  getAddressDecoder as getAddressDecoder28,
-  getAddressEncoder as getAddressEncoder28,
+  getAddressDecoder as getAddressDecoder27,
+  getAddressEncoder as getAddressEncoder27,
   getArrayDecoder as getArrayDecoder12,
   getArrayEncoder as getArrayEncoder12,
-  getBooleanDecoder as getBooleanDecoder6,
-  getBooleanEncoder as getBooleanEncoder6,
+  getBooleanDecoder as getBooleanDecoder4,
+  getBooleanEncoder as getBooleanEncoder4,
   getBytesDecoder as getBytesDecoder3,
   getBytesEncoder as getBytesEncoder3,
-  getOptionDecoder as getOptionDecoder4,
-  getOptionEncoder as getOptionEncoder4,
-  getStructDecoder as getStructDecoder46,
-  getStructEncoder as getStructEncoder46,
+  getOptionDecoder as getOptionDecoder5,
+  getOptionEncoder as getOptionEncoder5,
+  getStructDecoder as getStructDecoder45,
+  getStructEncoder as getStructEncoder45,
   getU16Decoder as getU16Decoder5,
   getU16Encoder as getU16Encoder5,
-  getU64Decoder as getU64Decoder24,
-  getU64Encoder as getU64Encoder24,
+  getU64Decoder as getU64Decoder25,
+  getU64Encoder as getU64Encoder25,
   getU8Decoder as getU8Decoder16,
   getU8Encoder as getU8Encoder16,
   transformEncoder as transformEncoder3
@@ -805,8 +805,6 @@ import {
   getAddressEncoder as getAddressEncoder7,
   getArrayDecoder as getArrayDecoder5,
   getArrayEncoder as getArrayEncoder5,
-  getBooleanDecoder as getBooleanDecoder2,
-  getBooleanEncoder as getBooleanEncoder2,
   getI64Decoder as getI64Decoder5,
   getI64Encoder as getI64Encoder5,
   getStructDecoder as getStructDecoder17,
@@ -829,13 +827,11 @@ function getMarketCreatedEventEncoder() {
     ["earlinessMultiplier", getU16Encoder3()],
     ["marketAuthority", getAddressEncoder7()],
     ["authorizedReaderPubkey", getArrayEncoder5(getU8Encoder8(), { size: 32 })],
-    ["allowUnstakingEarly", getBooleanEncoder2()],
     ["minStakeAmount", getU64Encoder7()],
     ["feeRates", getFeeRatesEncoder()],
     ["creatorFeeClaimer", getAddressEncoder7()],
     ["marketResolutionDeadlineSeconds", getU64Encoder7()],
-    ["minRevealPeriodSeconds", getU64Encoder7()],
-    ["maxRevealPeriodSeconds", getU64Encoder7()],
+    ["revealPeriodSeconds", getU64Encoder7()],
     ["timestamp", getI64Encoder5()]
   ]);
 }
@@ -850,13 +846,11 @@ function getMarketCreatedEventDecoder() {
     ["earlinessMultiplier", getU16Decoder3()],
     ["marketAuthority", getAddressDecoder7()],
     ["authorizedReaderPubkey", getArrayDecoder5(getU8Decoder8(), { size: 32 })],
-    ["allowUnstakingEarly", getBooleanDecoder2()],
     ["minStakeAmount", getU64Decoder7()],
     ["feeRates", getFeeRatesDecoder()],
     ["creatorFeeClaimer", getAddressDecoder7()],
     ["marketResolutionDeadlineSeconds", getU64Decoder7()],
-    ["minRevealPeriodSeconds", getU64Decoder7()],
-    ["maxRevealPeriodSeconds", getU64Decoder7()],
+    ["revealPeriodSeconds", getU64Decoder7()],
     ["timestamp", getI64Decoder5()]
   ]);
 }
@@ -977,8 +971,8 @@ import {
   getAddressEncoder as getAddressEncoder11,
   getArrayDecoder as getArrayDecoder6,
   getArrayEncoder as getArrayEncoder6,
-  getBooleanDecoder as getBooleanDecoder3,
-  getBooleanEncoder as getBooleanEncoder3,
+  getBooleanDecoder as getBooleanDecoder2,
+  getBooleanEncoder as getBooleanEncoder2,
   getDiscriminatedUnionDecoder as getDiscriminatedUnionDecoder3,
   getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder3,
   getOptionDecoder as getOptionDecoder3,
@@ -1018,7 +1012,7 @@ function getMXEAccountEncoder() {
               "fields",
               getTupleEncoder5([
                 getUtilityPubkeysEncoder(),
-                getArrayEncoder6(getBooleanEncoder3())
+                getArrayEncoder6(getBooleanEncoder2())
               ])
             ]
           ])
@@ -1055,7 +1049,7 @@ function getMXEAccountDecoder() {
               "fields",
               getTupleDecoder5([
                 getUtilityPubkeysDecoder(),
-                getArrayDecoder6(getBooleanDecoder3())
+                getArrayDecoder6(getBooleanDecoder2())
               ])
             ]
           ])
@@ -1191,20 +1185,20 @@ import {
   combineCodec as combineCodec29,
   getAddressDecoder as getAddressDecoder12,
   getAddressEncoder as getAddressEncoder12,
-  getBooleanDecoder as getBooleanDecoder4,
-  getBooleanEncoder as getBooleanEncoder4,
+  getBooleanDecoder as getBooleanDecoder3,
+  getBooleanEncoder as getBooleanEncoder3,
   getStructDecoder as getStructDecoder25,
   getStructEncoder as getStructEncoder25
 } from "@solana/kit";
 function getOnChainCircuitSourceEncoder() {
   return getStructEncoder25([
-    ["isCompleted", getBooleanEncoder4()],
+    ["isCompleted", getBooleanEncoder3()],
     ["uploadAuth", getAddressEncoder12()]
   ]);
 }
 function getOnChainCircuitSourceDecoder() {
   return getStructDecoder25([
-    ["isCompleted", getBooleanDecoder4()],
+    ["isCompleted", getBooleanDecoder3()],
     ["uploadAuth", getAddressDecoder12()]
   ]);
 }
@@ -1431,8 +1425,6 @@ import {
   combineCodec as combineCodec36,
   getAddressDecoder as getAddressDecoder16,
   getAddressEncoder as getAddressEncoder16,
-  getBooleanDecoder as getBooleanDecoder5,
-  getBooleanEncoder as getBooleanEncoder5,
   getI64Decoder as getI64Decoder12,
   getI64Encoder as getI64Encoder12,
   getStructDecoder as getStructDecoder30,
@@ -1446,7 +1438,6 @@ function getRewardAddedEventEncoder() {
     ["sponsor", getAddressEncoder16()],
     ["amount", getU64Encoder15()],
     ["totalRewardAmount", getU64Encoder15()],
-    ["locked", getBooleanEncoder5()],
     ["timestamp", getI64Encoder12()]
   ]);
 }
@@ -1456,7 +1447,6 @@ function getRewardAddedEventDecoder() {
     ["sponsor", getAddressDecoder16()],
     ["amount", getU64Decoder15()],
     ["totalRewardAmount", getU64Decoder15()],
-    ["locked", getBooleanDecoder5()],
     ["timestamp", getI64Decoder12()]
   ]);
 }
@@ -1467,7 +1457,7 @@ function getRewardAddedEventCodec() {
   );
 }
 
-// src/generated/types/rewardWithdrawnEvent.ts
+// src/generated/types/rewardsClaimedEvent.ts
 import {
   combineCodec as combineCodec37,
   getAddressDecoder as getAddressDecoder17,
@@ -1476,35 +1466,43 @@ import {
   getI64Encoder as getI64Encoder13,
   getStructDecoder as getStructDecoder31,
   getStructEncoder as getStructEncoder31,
+  getU32Decoder as getU32Decoder7,
+  getU32Encoder as getU32Encoder7,
   getU64Decoder as getU64Decoder16,
   getU64Encoder as getU64Encoder16
 } from "@solana/kit";
-function getRewardWithdrawnEventEncoder() {
+function getRewardsClaimedEventEncoder() {
   return getStructEncoder31([
+    ["owner", getAddressEncoder17()],
     ["market", getAddressEncoder17()],
-    ["sponsor", getAddressEncoder17()],
+    ["stakeAccount", getAddressEncoder17()],
+    ["stakeAccountId", getU32Encoder7()],
+    ["optionId", getU64Encoder16()],
     ["rewardAmount", getU64Encoder16()],
-    ["refundTokenAccount", getAddressEncoder17()],
+    ["score", getU64Encoder16()],
     ["timestamp", getI64Encoder13()]
   ]);
 }
-function getRewardWithdrawnEventDecoder() {
+function getRewardsClaimedEventDecoder() {
   return getStructDecoder31([
+    ["owner", getAddressDecoder17()],
     ["market", getAddressDecoder17()],
-    ["sponsor", getAddressDecoder17()],
+    ["stakeAccount", getAddressDecoder17()],
+    ["stakeAccountId", getU32Decoder7()],
+    ["optionId", getU64Decoder16()],
     ["rewardAmount", getU64Decoder16()],
-    ["refundTokenAccount", getAddressDecoder17()],
+    ["score", getU64Decoder16()],
     ["timestamp", getI64Decoder13()]
   ]);
 }
-function getRewardWithdrawnEventCodec() {
+function getRewardsClaimedEventCodec() {
   return combineCodec37(
-    getRewardWithdrawnEventEncoder(),
-    getRewardWithdrawnEventDecoder()
+    getRewardsClaimedEventEncoder(),
+    getRewardsClaimedEventDecoder()
   );
 }
 
-// src/generated/types/stakeAccountClosedEvent.ts
+// src/generated/types/rewardWithdrawnEvent.ts
 import {
   combineCodec as combineCodec38,
   getAddressDecoder as getAddressDecoder18,
@@ -1513,111 +1511,150 @@ import {
   getI64Encoder as getI64Encoder14,
   getStructDecoder as getStructDecoder32,
   getStructEncoder as getStructEncoder32,
-  getU32Decoder as getU32Decoder7,
-  getU32Encoder as getU32Encoder7,
   getU64Decoder as getU64Decoder17,
   getU64Encoder as getU64Encoder17
 } from "@solana/kit";
-function getStakeAccountClosedEventEncoder() {
+function getRewardWithdrawnEventEncoder() {
   return getStructEncoder32([
-    ["owner", getAddressEncoder18()],
     ["market", getAddressEncoder18()],
-    ["stakeAccount", getAddressEncoder18()],
-    ["stakeAccountId", getU32Encoder7()],
-    ["optionId", getU64Encoder17()],
+    ["sponsor", getAddressEncoder18()],
     ["rewardAmount", getU64Encoder17()],
-    ["stakedAtTimestamp", getU64Encoder17()],
-    ["stakeEndTimestamp", getU64Encoder17()],
-    ["stakeAmount", getU64Encoder17()],
-    ["score", getU64Encoder17()],
+    ["refundTokenAccount", getAddressEncoder18()],
     ["timestamp", getI64Encoder14()]
   ]);
 }
-function getStakeAccountClosedEventDecoder() {
+function getRewardWithdrawnEventDecoder() {
   return getStructDecoder32([
-    ["owner", getAddressDecoder18()],
     ["market", getAddressDecoder18()],
-    ["stakeAccount", getAddressDecoder18()],
-    ["stakeAccountId", getU32Decoder7()],
-    ["optionId", getU64Decoder17()],
+    ["sponsor", getAddressDecoder18()],
     ["rewardAmount", getU64Decoder17()],
-    ["stakedAtTimestamp", getU64Decoder17()],
-    ["stakeEndTimestamp", getU64Decoder17()],
-    ["stakeAmount", getU64Decoder17()],
-    ["score", getU64Decoder17()],
+    ["refundTokenAccount", getAddressDecoder18()],
     ["timestamp", getI64Decoder14()]
   ]);
 }
-function getStakeAccountClosedEventCodec() {
+function getRewardWithdrawnEventCodec() {
   return combineCodec38(
-    getStakeAccountClosedEventEncoder(),
-    getStakeAccountClosedEventDecoder()
+    getRewardWithdrawnEventEncoder(),
+    getRewardWithdrawnEventDecoder()
   );
 }
 
-// src/generated/types/stakeAccountInitializedEvent.ts
+// src/generated/types/stakeAccountClosedEvent.ts
 import {
   combineCodec as combineCodec39,
   getAddressDecoder as getAddressDecoder19,
   getAddressEncoder as getAddressEncoder19,
   getI64Decoder as getI64Decoder15,
   getI64Encoder as getI64Encoder15,
+  getOptionDecoder as getOptionDecoder4,
+  getOptionEncoder as getOptionEncoder4,
   getStructDecoder as getStructDecoder33,
   getStructEncoder as getStructEncoder33,
   getU32Decoder as getU32Decoder8,
-  getU32Encoder as getU32Encoder8
+  getU32Encoder as getU32Encoder8,
+  getU64Decoder as getU64Decoder18,
+  getU64Encoder as getU64Encoder18
 } from "@solana/kit";
-function getStakeAccountInitializedEventEncoder() {
+function getStakeAccountClosedEventEncoder() {
   return getStructEncoder33([
-    ["stakeAccount", getAddressEncoder19()],
     ["owner", getAddressEncoder19()],
     ["market", getAddressEncoder19()],
-    ["accountId", getU32Encoder8()],
+    ["stakeAccount", getAddressEncoder19()],
+    ["stakeAccountId", getU32Encoder8()],
+    ["optionId", getOptionEncoder4(getU64Encoder18())],
+    ["stakeAmount", getU64Encoder18()],
+    ["feeRefund", getU64Encoder18()],
+    ["stakedAtTimestamp", getU64Encoder18()],
+    ["stakeEndTimestamp", getU64Encoder18()],
+    ["score", getU64Encoder18()],
     ["timestamp", getI64Encoder15()]
   ]);
 }
-function getStakeAccountInitializedEventDecoder() {
+function getStakeAccountClosedEventDecoder() {
   return getStructDecoder33([
-    ["stakeAccount", getAddressDecoder19()],
     ["owner", getAddressDecoder19()],
     ["market", getAddressDecoder19()],
-    ["accountId", getU32Decoder8()],
+    ["stakeAccount", getAddressDecoder19()],
+    ["stakeAccountId", getU32Decoder8()],
+    ["optionId", getOptionDecoder4(getU64Decoder18())],
+    ["stakeAmount", getU64Decoder18()],
+    ["feeRefund", getU64Decoder18()],
+    ["stakedAtTimestamp", getU64Decoder18()],
+    ["stakeEndTimestamp", getU64Decoder18()],
+    ["score", getU64Decoder18()],
     ["timestamp", getI64Decoder15()]
   ]);
 }
-function getStakeAccountInitializedEventCodec() {
+function getStakeAccountClosedEventCodec() {
   return combineCodec39(
-    getStakeAccountInitializedEventEncoder(),
-    getStakeAccountInitializedEventDecoder()
+    getStakeAccountClosedEventEncoder(),
+    getStakeAccountClosedEventDecoder()
   );
 }
 
-// src/generated/types/stakedEvent.ts
+// src/generated/types/stakeAccountInitializedEvent.ts
 import {
   combineCodec as combineCodec40,
   getAddressDecoder as getAddressDecoder20,
   getAddressEncoder as getAddressEncoder20,
-  getArrayDecoder as getArrayDecoder9,
-  getArrayEncoder as getArrayEncoder9,
   getI64Decoder as getI64Decoder16,
   getI64Encoder as getI64Encoder16,
   getStructDecoder as getStructDecoder34,
   getStructEncoder as getStructEncoder34,
+  getU32Decoder as getU32Decoder9,
+  getU32Encoder as getU32Encoder9
+} from "@solana/kit";
+function getStakeAccountInitializedEventEncoder() {
+  return getStructEncoder34([
+    ["stakeAccount", getAddressEncoder20()],
+    ["owner", getAddressEncoder20()],
+    ["market", getAddressEncoder20()],
+    ["accountId", getU32Encoder9()],
+    ["timestamp", getI64Encoder16()]
+  ]);
+}
+function getStakeAccountInitializedEventDecoder() {
+  return getStructDecoder34([
+    ["stakeAccount", getAddressDecoder20()],
+    ["owner", getAddressDecoder20()],
+    ["market", getAddressDecoder20()],
+    ["accountId", getU32Decoder9()],
+    ["timestamp", getI64Decoder16()]
+  ]);
+}
+function getStakeAccountInitializedEventCodec() {
+  return combineCodec40(
+    getStakeAccountInitializedEventEncoder(),
+    getStakeAccountInitializedEventDecoder()
+  );
+}
+
+// src/generated/types/stakedEvent.ts
+import {
+  combineCodec as combineCodec41,
+  getAddressDecoder as getAddressDecoder21,
+  getAddressEncoder as getAddressEncoder21,
+  getArrayDecoder as getArrayDecoder9,
+  getArrayEncoder as getArrayEncoder9,
+  getI64Decoder as getI64Decoder17,
+  getI64Encoder as getI64Encoder17,
+  getStructDecoder as getStructDecoder35,
+  getStructEncoder as getStructEncoder35,
   getU128Decoder as getU128Decoder2,
   getU128Encoder as getU128Encoder2,
-  getU32Decoder as getU32Decoder9,
-  getU32Encoder as getU32Encoder9,
-  getU64Decoder as getU64Decoder18,
-  getU64Encoder as getU64Encoder18,
+  getU32Decoder as getU32Decoder10,
+  getU32Encoder as getU32Encoder10,
+  getU64Decoder as getU64Decoder19,
+  getU64Encoder as getU64Encoder19,
   getU8Decoder as getU8Decoder13,
   getU8Encoder as getU8Encoder13
 } from "@solana/kit";
 function getStakedEventEncoder() {
-  return getStructEncoder34([
-    ["user", getAddressEncoder20()],
-    ["market", getAddressEncoder20()],
-    ["stakeAccount", getAddressEncoder20()],
-    ["stakeAccountId", getU32Encoder9()],
+  return getStructEncoder35([
+    ["user", getAddressEncoder21()],
+    ["market", getAddressEncoder21()],
+    ["stakeAccount", getAddressEncoder21()],
+    ["stakeAccountId", getU32Encoder10()],
     ["stakeEncryptedOption", getArrayEncoder9(getU8Encoder13(), { size: 32 })],
     ["stakeStateNonce", getU128Encoder2()],
     [
@@ -1625,16 +1662,16 @@ function getStakedEventEncoder() {
       getArrayEncoder9(getU8Encoder13(), { size: 32 })
     ],
     ["stakeStateDisclosureNonce", getU128Encoder2()],
-    ["amount", getU64Encoder18()],
-    ["timestamp", getI64Encoder16()]
+    ["amount", getU64Encoder19()],
+    ["timestamp", getI64Encoder17()]
   ]);
 }
 function getStakedEventDecoder() {
-  return getStructDecoder34([
-    ["user", getAddressDecoder20()],
-    ["market", getAddressDecoder20()],
-    ["stakeAccount", getAddressDecoder20()],
-    ["stakeAccountId", getU32Decoder9()],
+  return getStructDecoder35([
+    ["user", getAddressDecoder21()],
+    ["market", getAddressDecoder21()],
+    ["stakeAccount", getAddressDecoder21()],
+    ["stakeAccountId", getU32Decoder10()],
     ["stakeEncryptedOption", getArrayDecoder9(getU8Decoder13(), { size: 32 })],
     ["stakeStateNonce", getU128Decoder2()],
     [
@@ -1642,47 +1679,47 @@ function getStakedEventDecoder() {
       getArrayDecoder9(getU8Decoder13(), { size: 32 })
     ],
     ["stakeStateDisclosureNonce", getU128Decoder2()],
-    ["amount", getU64Decoder18()],
-    ["timestamp", getI64Decoder16()]
+    ["amount", getU64Decoder19()],
+    ["timestamp", getI64Decoder17()]
   ]);
 }
 function getStakedEventCodec() {
-  return combineCodec40(getStakedEventEncoder(), getStakedEventDecoder());
+  return combineCodec41(getStakedEventEncoder(), getStakedEventDecoder());
 }
 
 // src/generated/types/stakeOutput.ts
 import {
-  combineCodec as combineCodec41,
-  getStructDecoder as getStructDecoder35,
-  getStructEncoder as getStructEncoder35
+  combineCodec as combineCodec42,
+  getStructDecoder as getStructDecoder36,
+  getStructEncoder as getStructEncoder36
 } from "@solana/kit";
 function getStakeOutputEncoder() {
-  return getStructEncoder35([["field0", getStakeOutputStruct0Encoder()]]);
+  return getStructEncoder36([["field0", getStakeOutputStruct0Encoder()]]);
 }
 function getStakeOutputDecoder() {
-  return getStructDecoder35([["field0", getStakeOutputStruct0Decoder()]]);
+  return getStructDecoder36([["field0", getStakeOutputStruct0Decoder()]]);
 }
 function getStakeOutputCodec() {
-  return combineCodec41(getStakeOutputEncoder(), getStakeOutputDecoder());
+  return combineCodec42(getStakeOutputEncoder(), getStakeOutputDecoder());
 }
 
 // src/generated/types/stakeOutputStruct0.ts
 import {
-  combineCodec as combineCodec42,
+  combineCodec as combineCodec43,
   getArrayDecoder as getArrayDecoder10,
   getArrayEncoder as getArrayEncoder10,
-  getStructDecoder as getStructDecoder36,
-  getStructEncoder as getStructEncoder36,
+  getStructDecoder as getStructDecoder37,
+  getStructEncoder as getStructEncoder37,
   getU128Decoder as getU128Decoder3,
   getU128Encoder as getU128Encoder3,
   getU8Decoder as getU8Decoder14,
   getU8Encoder as getU8Encoder14
 } from "@solana/kit";
 function getStakeOutputStruct0Encoder() {
-  return getStructEncoder36([
+  return getStructEncoder37([
     [
       "field0",
-      getStructEncoder36([
+      getStructEncoder37([
         ["encryptionKey", getArrayEncoder10(getU8Encoder14(), { size: 32 })],
         ["nonce", getU128Encoder3()],
         [
@@ -1695,7 +1732,7 @@ function getStakeOutputStruct0Encoder() {
     ],
     [
       "field1",
-      getStructEncoder36([
+      getStructEncoder37([
         ["encryptionKey", getArrayEncoder10(getU8Encoder14(), { size: 32 })],
         ["nonce", getU128Encoder3()],
         [
@@ -1709,10 +1746,10 @@ function getStakeOutputStruct0Encoder() {
   ]);
 }
 function getStakeOutputStruct0Decoder() {
-  return getStructDecoder36([
+  return getStructDecoder37([
     [
       "field0",
-      getStructDecoder36([
+      getStructDecoder37([
         ["encryptionKey", getArrayDecoder10(getU8Decoder14(), { size: 32 })],
         ["nonce", getU128Decoder3()],
         [
@@ -1725,7 +1762,7 @@ function getStakeOutputStruct0Decoder() {
     ],
     [
       "field1",
-      getStructDecoder36([
+      getStructDecoder37([
         ["encryptionKey", getArrayDecoder10(getU8Decoder14(), { size: 32 })],
         ["nonce", getU128Decoder3()],
         [
@@ -1739,56 +1776,13 @@ function getStakeOutputStruct0Decoder() {
   ]);
 }
 function getStakeOutputStruct0Codec() {
-  return combineCodec42(
+  return combineCodec43(
     getStakeOutputStruct0Encoder(),
     getStakeOutputStruct0Decoder()
   );
 }
 
 // src/generated/types/stakeRevealedEvent.ts
-import {
-  combineCodec as combineCodec43,
-  getAddressDecoder as getAddressDecoder21,
-  getAddressEncoder as getAddressEncoder21,
-  getI64Decoder as getI64Decoder17,
-  getI64Encoder as getI64Encoder17,
-  getStructDecoder as getStructDecoder37,
-  getStructEncoder as getStructEncoder37,
-  getU32Decoder as getU32Decoder10,
-  getU32Encoder as getU32Encoder10,
-  getU64Decoder as getU64Decoder19,
-  getU64Encoder as getU64Encoder19
-} from "@solana/kit";
-function getStakeRevealedEventEncoder() {
-  return getStructEncoder37([
-    ["user", getAddressEncoder21()],
-    ["market", getAddressEncoder21()],
-    ["stakeAccount", getAddressEncoder21()],
-    ["stakeAccountId", getU32Encoder10()],
-    ["stakeAmount", getU64Encoder19()],
-    ["selectedOption", getU64Encoder19()],
-    ["timestamp", getI64Encoder17()]
-  ]);
-}
-function getStakeRevealedEventDecoder() {
-  return getStructDecoder37([
-    ["user", getAddressDecoder21()],
-    ["market", getAddressDecoder21()],
-    ["stakeAccount", getAddressDecoder21()],
-    ["stakeAccountId", getU32Decoder10()],
-    ["stakeAmount", getU64Decoder19()],
-    ["selectedOption", getU64Decoder19()],
-    ["timestamp", getI64Decoder17()]
-  ]);
-}
-function getStakeRevealedEventCodec() {
-  return combineCodec43(
-    getStakeRevealedEventEncoder(),
-    getStakeRevealedEventDecoder()
-  );
-}
-
-// src/generated/types/stakingPausedEvent.ts
 import {
   combineCodec as combineCodec44,
   getAddressDecoder as getAddressDecoder22,
@@ -1796,28 +1790,42 @@ import {
   getI64Decoder as getI64Decoder18,
   getI64Encoder as getI64Encoder18,
   getStructDecoder as getStructDecoder38,
-  getStructEncoder as getStructEncoder38
+  getStructEncoder as getStructEncoder38,
+  getU32Decoder as getU32Decoder11,
+  getU32Encoder as getU32Encoder11,
+  getU64Decoder as getU64Decoder20,
+  getU64Encoder as getU64Encoder20
 } from "@solana/kit";
-function getStakingPausedEventEncoder() {
+function getStakeRevealedEventEncoder() {
   return getStructEncoder38([
+    ["user", getAddressEncoder22()],
     ["market", getAddressEncoder22()],
+    ["stakeAccount", getAddressEncoder22()],
+    ["stakeAccountId", getU32Encoder11()],
+    ["stakeAmount", getU64Encoder20()],
+    ["selectedOption", getU64Encoder20()],
     ["timestamp", getI64Encoder18()]
   ]);
 }
-function getStakingPausedEventDecoder() {
+function getStakeRevealedEventDecoder() {
   return getStructDecoder38([
+    ["user", getAddressDecoder22()],
     ["market", getAddressDecoder22()],
+    ["stakeAccount", getAddressDecoder22()],
+    ["stakeAccountId", getU32Decoder11()],
+    ["stakeAmount", getU64Decoder20()],
+    ["selectedOption", getU64Decoder20()],
     ["timestamp", getI64Decoder18()]
   ]);
 }
-function getStakingPausedEventCodec() {
+function getStakeRevealedEventCodec() {
   return combineCodec44(
-    getStakingPausedEventEncoder(),
-    getStakingPausedEventDecoder()
+    getStakeRevealedEventEncoder(),
+    getStakeRevealedEventDecoder()
   );
 }
 
-// src/generated/types/stakingResumedEvent.ts
+// src/generated/types/stuckStakeClosedEvent.ts
 import {
   combineCodec as combineCodec45,
   getAddressDecoder as getAddressDecoder23,
@@ -1825,93 +1833,102 @@ import {
   getI64Decoder as getI64Decoder19,
   getI64Encoder as getI64Encoder19,
   getStructDecoder as getStructDecoder39,
-  getStructEncoder as getStructEncoder39
+  getStructEncoder as getStructEncoder39,
+  getU32Decoder as getU32Decoder12,
+  getU32Encoder as getU32Encoder12,
+  getU64Decoder as getU64Decoder21,
+  getU64Encoder as getU64Encoder21
 } from "@solana/kit";
-function getStakingResumedEventEncoder() {
+function getStuckStakeClosedEventEncoder() {
   return getStructEncoder39([
+    ["owner", getAddressEncoder23()],
     ["market", getAddressEncoder23()],
+    ["stakeAccount", getAddressEncoder23()],
+    ["stakeAccountId", getU32Encoder12()],
+    ["refundedAmount", getU64Encoder21()],
+    ["refundedPlatformFee", getU64Encoder21()],
+    ["refundedRewardPoolFee", getU64Encoder21()],
+    ["refundedCreatorFee", getU64Encoder21()],
     ["timestamp", getI64Encoder19()]
   ]);
 }
-function getStakingResumedEventDecoder() {
+function getStuckStakeClosedEventDecoder() {
   return getStructDecoder39([
+    ["owner", getAddressDecoder23()],
     ["market", getAddressDecoder23()],
+    ["stakeAccount", getAddressDecoder23()],
+    ["stakeAccountId", getU32Decoder12()],
+    ["refundedAmount", getU64Decoder21()],
+    ["refundedPlatformFee", getU64Decoder21()],
+    ["refundedRewardPoolFee", getU64Decoder21()],
+    ["refundedCreatorFee", getU64Decoder21()],
     ["timestamp", getI64Decoder19()]
   ]);
 }
-function getStakingResumedEventCodec() {
+function getStuckStakeClosedEventCodec() {
   return combineCodec45(
-    getStakingResumedEventEncoder(),
-    getStakingResumedEventDecoder()
+    getStuckStakeClosedEventEncoder(),
+    getStuckStakeClosedEventDecoder()
   );
 }
 
-// src/generated/types/stuckStakeClosedEvent.ts
+// src/generated/types/timestamp.ts
 import {
   combineCodec as combineCodec46,
+  getStructDecoder as getStructDecoder40,
+  getStructEncoder as getStructEncoder40,
+  getU64Decoder as getU64Decoder22,
+  getU64Encoder as getU64Encoder22
+} from "@solana/kit";
+function getTimestampEncoder() {
+  return getStructEncoder40([["timestamp", getU64Encoder22()]]);
+}
+function getTimestampDecoder() {
+  return getStructDecoder40([["timestamp", getU64Decoder22()]]);
+}
+function getTimestampCodec() {
+  return combineCodec46(getTimestampEncoder(), getTimestampDecoder());
+}
+
+// src/generated/types/unstakedEvent.ts
+import {
+  combineCodec as combineCodec47,
   getAddressDecoder as getAddressDecoder24,
   getAddressEncoder as getAddressEncoder24,
   getI64Decoder as getI64Decoder20,
   getI64Encoder as getI64Encoder20,
-  getStructDecoder as getStructDecoder40,
-  getStructEncoder as getStructEncoder40,
-  getU32Decoder as getU32Decoder11,
-  getU32Encoder as getU32Encoder11,
-  getU64Decoder as getU64Decoder20,
-  getU64Encoder as getU64Encoder20
+  getStructDecoder as getStructDecoder41,
+  getStructEncoder as getStructEncoder41,
+  getU32Decoder as getU32Decoder13,
+  getU32Encoder as getU32Encoder13,
+  getU64Decoder as getU64Decoder23,
+  getU64Encoder as getU64Encoder23
 } from "@solana/kit";
-function getStuckStakeClosedEventEncoder() {
-  return getStructEncoder40([
+function getUnstakedEventEncoder() {
+  return getStructEncoder41([
     ["owner", getAddressEncoder24()],
     ["market", getAddressEncoder24()],
     ["stakeAccount", getAddressEncoder24()],
-    ["stakeAccountId", getU32Encoder11()],
-    ["refundedAmount", getU64Encoder20()],
-    ["refundedPlatformFee", getU64Encoder20()],
-    ["refundedRewardPoolFee", getU64Encoder20()],
-    ["refundedCreatorFee", getU64Encoder20()],
+    ["stakeAccountId", getU32Encoder13()],
+    ["amount", getU64Encoder23()],
     ["timestamp", getI64Encoder20()]
   ]);
 }
-function getStuckStakeClosedEventDecoder() {
-  return getStructDecoder40([
+function getUnstakedEventDecoder() {
+  return getStructDecoder41([
     ["owner", getAddressDecoder24()],
     ["market", getAddressDecoder24()],
     ["stakeAccount", getAddressDecoder24()],
-    ["stakeAccountId", getU32Decoder11()],
-    ["refundedAmount", getU64Decoder20()],
-    ["refundedPlatformFee", getU64Decoder20()],
-    ["refundedRewardPoolFee", getU64Decoder20()],
-    ["refundedCreatorFee", getU64Decoder20()],
+    ["stakeAccountId", getU32Decoder13()],
+    ["amount", getU64Decoder23()],
     ["timestamp", getI64Decoder20()]
   ]);
 }
-function getStuckStakeClosedEventCodec() {
-  return combineCodec46(
-    getStuckStakeClosedEventEncoder(),
-    getStuckStakeClosedEventDecoder()
-  );
+function getUnstakedEventCodec() {
+  return combineCodec47(getUnstakedEventEncoder(), getUnstakedEventDecoder());
 }
 
-// src/generated/types/timestamp.ts
-import {
-  combineCodec as combineCodec47,
-  getStructDecoder as getStructDecoder41,
-  getStructEncoder as getStructEncoder41,
-  getU64Decoder as getU64Decoder21,
-  getU64Encoder as getU64Encoder21
-} from "@solana/kit";
-function getTimestampEncoder() {
-  return getStructEncoder41([["timestamp", getU64Encoder21()]]);
-}
-function getTimestampDecoder() {
-  return getStructDecoder41([["timestamp", getU64Decoder21()]]);
-}
-function getTimestampCodec() {
-  return combineCodec47(getTimestampEncoder(), getTimestampDecoder());
-}
-
-// src/generated/types/unstakedEvent.ts
+// src/generated/types/updateAuthorityChangedEvent.ts
 import {
   combineCodec as combineCodec48,
   getAddressDecoder as getAddressDecoder25,
@@ -1919,64 +1936,26 @@ import {
   getI64Decoder as getI64Decoder21,
   getI64Encoder as getI64Encoder21,
   getStructDecoder as getStructDecoder42,
-  getStructEncoder as getStructEncoder42,
-  getU32Decoder as getU32Decoder12,
-  getU32Encoder as getU32Encoder12,
-  getU64Decoder as getU64Decoder22,
-  getU64Encoder as getU64Encoder22
+  getStructEncoder as getStructEncoder42
 } from "@solana/kit";
-function getUnstakedEventEncoder() {
+function getUpdateAuthorityChangedEventEncoder() {
   return getStructEncoder42([
-    ["owner", getAddressEncoder25()],
-    ["market", getAddressEncoder25()],
-    ["stakeAccount", getAddressEncoder25()],
-    ["stakeAccountId", getU32Encoder12()],
-    ["amount", getU64Encoder22()],
+    ["platformConfig", getAddressEncoder25()],
+    ["oldValue", getAddressEncoder25()],
+    ["newValue", getAddressEncoder25()],
     ["timestamp", getI64Encoder21()]
   ]);
 }
-function getUnstakedEventDecoder() {
+function getUpdateAuthorityChangedEventDecoder() {
   return getStructDecoder42([
-    ["owner", getAddressDecoder25()],
-    ["market", getAddressDecoder25()],
-    ["stakeAccount", getAddressDecoder25()],
-    ["stakeAccountId", getU32Decoder12()],
-    ["amount", getU64Decoder22()],
+    ["platformConfig", getAddressDecoder25()],
+    ["oldValue", getAddressDecoder25()],
+    ["newValue", getAddressDecoder25()],
     ["timestamp", getI64Decoder21()]
   ]);
 }
-function getUnstakedEventCodec() {
-  return combineCodec48(getUnstakedEventEncoder(), getUnstakedEventDecoder());
-}
-
-// src/generated/types/updateAuthorityChangedEvent.ts
-import {
-  combineCodec as combineCodec49,
-  getAddressDecoder as getAddressDecoder26,
-  getAddressEncoder as getAddressEncoder26,
-  getI64Decoder as getI64Decoder22,
-  getI64Encoder as getI64Encoder22,
-  getStructDecoder as getStructDecoder43,
-  getStructEncoder as getStructEncoder43
-} from "@solana/kit";
-function getUpdateAuthorityChangedEventEncoder() {
-  return getStructEncoder43([
-    ["platformConfig", getAddressEncoder26()],
-    ["oldValue", getAddressEncoder26()],
-    ["newValue", getAddressEncoder26()],
-    ["timestamp", getI64Encoder22()]
-  ]);
-}
-function getUpdateAuthorityChangedEventDecoder() {
-  return getStructDecoder43([
-    ["platformConfig", getAddressDecoder26()],
-    ["oldValue", getAddressDecoder26()],
-    ["newValue", getAddressDecoder26()],
-    ["timestamp", getI64Decoder22()]
-  ]);
-}
 function getUpdateAuthorityChangedEventCodec() {
-  return combineCodec49(
+  return combineCodec48(
     getUpdateAuthorityChangedEventEncoder(),
     getUpdateAuthorityChangedEventDecoder()
   );
@@ -1984,16 +1963,16 @@ function getUpdateAuthorityChangedEventCodec() {
 
 // src/generated/types/utilityPubkeys.ts
 import {
-  combineCodec as combineCodec50,
+  combineCodec as combineCodec49,
   getArrayDecoder as getArrayDecoder11,
   getArrayEncoder as getArrayEncoder11,
-  getStructDecoder as getStructDecoder44,
-  getStructEncoder as getStructEncoder44,
+  getStructDecoder as getStructDecoder43,
+  getStructEncoder as getStructEncoder43,
   getU8Decoder as getU8Decoder15,
   getU8Encoder as getU8Encoder15
 } from "@solana/kit";
 function getUtilityPubkeysEncoder() {
-  return getStructEncoder44([
+  return getStructEncoder43([
     ["x25519Pubkey", getArrayEncoder11(getU8Encoder15(), { size: 32 })],
     ["ed25519VerifyingKey", getArrayEncoder11(getU8Encoder15(), { size: 32 })],
     ["elgamalPubkey", getArrayEncoder11(getU8Encoder15(), { size: 32 })],
@@ -2001,7 +1980,7 @@ function getUtilityPubkeysEncoder() {
   ]);
 }
 function getUtilityPubkeysDecoder() {
-  return getStructDecoder44([
+  return getStructDecoder43([
     ["x25519Pubkey", getArrayDecoder11(getU8Decoder15(), { size: 32 })],
     ["ed25519VerifyingKey", getArrayDecoder11(getU8Decoder15(), { size: 32 })],
     ["elgamalPubkey", getArrayDecoder11(getU8Decoder15(), { size: 32 })],
@@ -2009,47 +1988,47 @@ function getUtilityPubkeysDecoder() {
   ]);
 }
 function getUtilityPubkeysCodec() {
-  return combineCodec50(getUtilityPubkeysEncoder(), getUtilityPubkeysDecoder());
+  return combineCodec49(getUtilityPubkeysEncoder(), getUtilityPubkeysDecoder());
 }
 
 // src/generated/types/winningOptionSetEvent.ts
 import {
-  combineCodec as combineCodec51,
-  getAddressDecoder as getAddressDecoder27,
-  getAddressEncoder as getAddressEncoder27,
-  getI64Decoder as getI64Decoder23,
-  getI64Encoder as getI64Encoder23,
-  getStructDecoder as getStructDecoder45,
-  getStructEncoder as getStructEncoder45,
+  combineCodec as combineCodec50,
+  getAddressDecoder as getAddressDecoder26,
+  getAddressEncoder as getAddressEncoder26,
+  getI64Decoder as getI64Decoder22,
+  getI64Encoder as getI64Encoder22,
+  getStructDecoder as getStructDecoder44,
+  getStructEncoder as getStructEncoder44,
   getU16Decoder as getU16Decoder4,
   getU16Encoder as getU16Encoder4,
-  getU64Decoder as getU64Decoder23,
-  getU64Encoder as getU64Encoder23
+  getU64Decoder as getU64Decoder24,
+  getU64Encoder as getU64Encoder24
 } from "@solana/kit";
 function getWinningOptionSetEventEncoder() {
-  return getStructEncoder45([
-    ["market", getAddressEncoder27()],
-    ["marketAuthority", getAddressEncoder27()],
-    ["option", getAddressEncoder27()],
-    ["optionId", getU64Encoder23()],
+  return getStructEncoder44([
+    ["market", getAddressEncoder26()],
+    ["marketAuthority", getAddressEncoder26()],
+    ["option", getAddressEncoder26()],
+    ["optionId", getU64Encoder24()],
     ["rewardBp", getU16Encoder4()],
     ["winningOptionAllocation", getU16Encoder4()],
-    ["timestamp", getI64Encoder23()]
+    ["timestamp", getI64Encoder22()]
   ]);
 }
 function getWinningOptionSetEventDecoder() {
-  return getStructDecoder45([
-    ["market", getAddressDecoder27()],
-    ["marketAuthority", getAddressDecoder27()],
-    ["option", getAddressDecoder27()],
-    ["optionId", getU64Decoder23()],
+  return getStructDecoder44([
+    ["market", getAddressDecoder26()],
+    ["marketAuthority", getAddressDecoder26()],
+    ["option", getAddressDecoder26()],
+    ["optionId", getU64Decoder24()],
     ["rewardBp", getU16Decoder4()],
     ["winningOptionAllocation", getU16Decoder4()],
-    ["timestamp", getI64Decoder23()]
+    ["timestamp", getI64Decoder22()]
   ]);
 }
 function getWinningOptionSetEventCodec() {
-  return combineCodec51(
+  return combineCodec50(
     getWinningOptionSetEventEncoder(),
     getWinningOptionSetEventDecoder()
   );
@@ -2073,71 +2052,65 @@ function getOpportunityMarketDiscriminatorBytes() {
 }
 function getOpportunityMarketEncoder() {
   return transformEncoder3(
-    getStructEncoder46([
+    getStructEncoder45([
       ["discriminator", fixEncoderSize3(getBytesEncoder3(), 8)],
       ["bump", getU8Encoder16()],
-      ["creator", getAddressEncoder28()],
-      ["index", getU64Encoder24()],
-      ["totalOptions", getU64Encoder24()],
-      ["platform", getAddressEncoder28()],
-      ["stakeEndTimestamp", getOptionEncoder4(getU64Encoder24())],
-      ["resolvedAtTimestamp", getOptionEncoder4(getU64Encoder24())],
+      ["creator", getAddressEncoder27()],
+      ["index", getU64Encoder25()],
+      ["totalOptions", getU64Encoder25()],
+      ["platform", getAddressEncoder27()],
+      ["stakeEndTimestamp", getOptionEncoder5(getU64Encoder25())],
+      ["resolvedAtTimestamp", getOptionEncoder5(getU64Encoder25())],
       ["winningOptionAllocation", getU16Encoder5()],
-      ["rewardAmount", getU64Encoder24()],
-      ["marketAuthority", getAddressEncoder28()],
-      ["revealPeriodAuthority", getAddressEncoder28()],
-      ["mint", getAddressEncoder28()],
-      ["earlinessCutoffSeconds", getU64Encoder24()],
+      ["winningOptionActiveBp", getU16Encoder5()],
+      ["rewardAmount", getU64Encoder25()],
+      ["marketAuthority", getAddressEncoder27()],
+      ["mint", getAddressEncoder27()],
+      ["earlinessCutoffSeconds", getU64Encoder25()],
       ["earlinessMultiplier", getU16Encoder5()],
-      ["allowUnstakingEarly", getBooleanEncoder6()],
       ["authorizedReaderPubkey", getArrayEncoder12(getU8Encoder16(), { size: 32 })],
-      ["stakingPaused", getBooleanEncoder6()],
       ["feeRates", getFeeRatesEncoder()],
-      ["collectedPlatformFees", getU64Encoder24()],
-      ["collectedCreatorFees", getU64Encoder24()],
-      ["creatorFeeClaimer", getAddressEncoder28()],
-      ["marketResolutionDeadlineSeconds", getU64Encoder24()],
-      ["minRevealPeriodSeconds", getU64Encoder24()],
-      ["maxRevealPeriodSeconds", getU64Encoder24()],
-      ["revealEnded", getBooleanEncoder6()],
-      ["minStakeAmount", getU64Encoder24()]
+      ["collectedPlatformFees", getU64Encoder25()],
+      ["collectedCreatorFees", getU64Encoder25()],
+      ["creatorFeeClaimer", getAddressEncoder27()],
+      ["marketResolutionDeadlineSeconds", getU64Encoder25()],
+      ["revealPeriodSeconds", getU64Encoder25()],
+      ["revealEnded", getBooleanEncoder4()],
+      ["minStakeAmount", getU64Encoder25()]
     ]),
     (value) => ({ ...value, discriminator: OPPORTUNITY_MARKET_DISCRIMINATOR })
   );
 }
 function getOpportunityMarketDecoder() {
-  return getStructDecoder46([
+  return getStructDecoder45([
     ["discriminator", fixDecoderSize3(getBytesDecoder3(), 8)],
     ["bump", getU8Decoder16()],
-    ["creator", getAddressDecoder28()],
-    ["index", getU64Decoder24()],
-    ["totalOptions", getU64Decoder24()],
-    ["platform", getAddressDecoder28()],
-    ["stakeEndTimestamp", getOptionDecoder4(getU64Decoder24())],
-    ["resolvedAtTimestamp", getOptionDecoder4(getU64Decoder24())],
+    ["creator", getAddressDecoder27()],
+    ["index", getU64Decoder25()],
+    ["totalOptions", getU64Decoder25()],
+    ["platform", getAddressDecoder27()],
+    ["stakeEndTimestamp", getOptionDecoder5(getU64Decoder25())],
+    ["resolvedAtTimestamp", getOptionDecoder5(getU64Decoder25())],
     ["winningOptionAllocation", getU16Decoder5()],
-    ["rewardAmount", getU64Decoder24()],
-    ["marketAuthority", getAddressDecoder28()],
-    ["revealPeriodAuthority", getAddressDecoder28()],
-    ["mint", getAddressDecoder28()],
-    ["earlinessCutoffSeconds", getU64Decoder24()],
+    ["winningOptionActiveBp", getU16Decoder5()],
+    ["rewardAmount", getU64Decoder25()],
+    ["marketAuthority", getAddressDecoder27()],
+    ["mint", getAddressDecoder27()],
+    ["earlinessCutoffSeconds", getU64Decoder25()],
     ["earlinessMultiplier", getU16Decoder5()],
-    ["allowUnstakingEarly", getBooleanDecoder6()],
     ["authorizedReaderPubkey", getArrayDecoder12(getU8Decoder16(), { size: 32 })],
-    ["stakingPaused", getBooleanDecoder6()],
     ["feeRates", getFeeRatesDecoder()],
-    ["collectedPlatformFees", getU64Decoder24()],
-    ["collectedCreatorFees", getU64Decoder24()],
-    ["creatorFeeClaimer", getAddressDecoder28()],
-    ["marketResolutionDeadlineSeconds", getU64Decoder24()],
-    ["minRevealPeriodSeconds", getU64Decoder24()],
-    ["maxRevealPeriodSeconds", getU64Decoder24()],
-    ["revealEnded", getBooleanDecoder6()],
-    ["minStakeAmount", getU64Decoder24()]
+    ["collectedPlatformFees", getU64Decoder25()],
+    ["collectedCreatorFees", getU64Decoder25()],
+    ["creatorFeeClaimer", getAddressDecoder27()],
+    ["marketResolutionDeadlineSeconds", getU64Decoder25()],
+    ["revealPeriodSeconds", getU64Decoder25()],
+    ["revealEnded", getBooleanDecoder4()],
+    ["minStakeAmount", getU64Decoder25()]
   ]);
 }
 function getOpportunityMarketCodec() {
-  return combineCodec52(
+  return combineCodec51(
     getOpportunityMarketEncoder(),
     getOpportunityMarketDecoder()
   );
@@ -2177,26 +2150,26 @@ async function fetchAllMaybeOpportunityMarket(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists4,
   assertAccountsExist as assertAccountsExist4,
-  combineCodec as combineCodec53,
+  combineCodec as combineCodec52,
   decodeAccount as decodeAccount4,
   fetchEncodedAccount as fetchEncodedAccount4,
   fetchEncodedAccounts as fetchEncodedAccounts4,
   fixDecoderSize as fixDecoderSize4,
   fixEncoderSize as fixEncoderSize4,
-  getAddressDecoder as getAddressDecoder29,
-  getAddressEncoder as getAddressEncoder29,
+  getAddressDecoder as getAddressDecoder28,
+  getAddressEncoder as getAddressEncoder28,
+  getBooleanDecoder as getBooleanDecoder5,
+  getBooleanEncoder as getBooleanEncoder5,
   getBytesDecoder as getBytesDecoder4,
   getBytesEncoder as getBytesEncoder4,
-  getOptionDecoder as getOptionDecoder5,
-  getOptionEncoder as getOptionEncoder5,
-  getStructDecoder as getStructDecoder47,
-  getStructEncoder as getStructEncoder47,
+  getStructDecoder as getStructDecoder46,
+  getStructEncoder as getStructEncoder46,
   getU128Decoder as getU128Decoder4,
   getU128Encoder as getU128Encoder4,
   getU16Decoder as getU16Decoder6,
   getU16Encoder as getU16Encoder6,
-  getU64Decoder as getU64Decoder25,
-  getU64Encoder as getU64Encoder25,
+  getU64Decoder as getU64Decoder26,
+  getU64Encoder as getU64Encoder26,
   getU8Decoder as getU8Decoder17,
   getU8Encoder as getU8Encoder17,
   transformEncoder as transformEncoder4
@@ -2218,15 +2191,16 @@ function getOpportunityMarketOptionDiscriminatorBytes() {
 }
 function getOpportunityMarketOptionEncoder() {
   return transformEncoder4(
-    getStructEncoder47([
+    getStructEncoder46([
       ["discriminator", fixEncoderSize4(getBytesEncoder4(), 8)],
       ["bump", getU8Encoder17()],
-      ["id", getU64Encoder25()],
-      ["creator", getAddressEncoder29()],
-      ["createdAt", getU64Encoder25()],
-      ["totalStaked", getU64Encoder25()],
+      ["id", getU64Encoder26()],
+      ["creator", getAddressEncoder28()],
+      ["createdAt", getU64Encoder26()],
+      ["unclaimedStake", getU64Encoder26()],
       ["totalScore", getU128Encoder4()],
-      ["rewardBp", getOptionEncoder5(getU16Encoder6())]
+      ["rewardBp", getU16Encoder6()],
+      ["includedInActiveBp", getBooleanEncoder5()]
     ]),
     (value) => ({
       ...value,
@@ -2235,19 +2209,20 @@ function getOpportunityMarketOptionEncoder() {
   );
 }
 function getOpportunityMarketOptionDecoder() {
-  return getStructDecoder47([
+  return getStructDecoder46([
     ["discriminator", fixDecoderSize4(getBytesDecoder4(), 8)],
     ["bump", getU8Decoder17()],
-    ["id", getU64Decoder25()],
-    ["creator", getAddressDecoder29()],
-    ["createdAt", getU64Decoder25()],
-    ["totalStaked", getU64Decoder25()],
+    ["id", getU64Decoder26()],
+    ["creator", getAddressDecoder28()],
+    ["createdAt", getU64Decoder26()],
+    ["unclaimedStake", getU64Decoder26()],
     ["totalScore", getU128Decoder4()],
-    ["rewardBp", getOptionDecoder5(getU16Decoder6())]
+    ["rewardBp", getU16Decoder6()],
+    ["includedInActiveBp", getBooleanDecoder5()]
   ]);
 }
 function getOpportunityMarketOptionCodec() {
-  return combineCodec53(
+  return combineCodec52(
     getOpportunityMarketOptionEncoder(),
     getOpportunityMarketOptionDecoder()
   );
@@ -2291,22 +2266,20 @@ async function fetchAllMaybeOpportunityMarketOption(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists5,
   assertAccountsExist as assertAccountsExist5,
-  combineCodec as combineCodec54,
+  combineCodec as combineCodec53,
   decodeAccount as decodeAccount5,
   fetchEncodedAccount as fetchEncodedAccount5,
   fetchEncodedAccounts as fetchEncodedAccounts5,
   fixDecoderSize as fixDecoderSize5,
   fixEncoderSize as fixEncoderSize5,
-  getAddressDecoder as getAddressDecoder30,
-  getAddressEncoder as getAddressEncoder30,
-  getBooleanDecoder as getBooleanDecoder7,
-  getBooleanEncoder as getBooleanEncoder7,
+  getAddressDecoder as getAddressDecoder29,
+  getAddressEncoder as getAddressEncoder29,
   getBytesDecoder as getBytesDecoder5,
   getBytesEncoder as getBytesEncoder5,
-  getStructDecoder as getStructDecoder48,
-  getStructEncoder as getStructEncoder48,
-  getU64Decoder as getU64Decoder26,
-  getU64Encoder as getU64Encoder26,
+  getStructDecoder as getStructDecoder47,
+  getStructEncoder as getStructEncoder47,
+  getU64Decoder as getU64Decoder27,
+  getU64Encoder as getU64Encoder27,
   getU8Decoder as getU8Decoder18,
   getU8Encoder as getU8Encoder18,
   transformEncoder as transformEncoder5
@@ -2328,13 +2301,12 @@ function getOpportunityMarketSponsorDiscriminatorBytes() {
 }
 function getOpportunityMarketSponsorEncoder() {
   return transformEncoder5(
-    getStructEncoder48([
+    getStructEncoder47([
       ["discriminator", fixEncoderSize5(getBytesEncoder5(), 8)],
       ["bump", getU8Encoder18()],
-      ["sponsor", getAddressEncoder30()],
-      ["market", getAddressEncoder30()],
-      ["rewardDeposited", getU64Encoder26()],
-      ["rewardLocked", getBooleanEncoder7()]
+      ["sponsor", getAddressEncoder29()],
+      ["market", getAddressEncoder29()],
+      ["rewardDeposited", getU64Encoder27()]
     ]),
     (value) => ({
       ...value,
@@ -2343,17 +2315,16 @@ function getOpportunityMarketSponsorEncoder() {
   );
 }
 function getOpportunityMarketSponsorDecoder() {
-  return getStructDecoder48([
+  return getStructDecoder47([
     ["discriminator", fixDecoderSize5(getBytesDecoder5(), 8)],
     ["bump", getU8Decoder18()],
-    ["sponsor", getAddressDecoder30()],
-    ["market", getAddressDecoder30()],
-    ["rewardDeposited", getU64Decoder26()],
-    ["rewardLocked", getBooleanDecoder7()]
+    ["sponsor", getAddressDecoder29()],
+    ["market", getAddressDecoder29()],
+    ["rewardDeposited", getU64Decoder27()]
   ]);
 }
 function getOpportunityMarketSponsorCodec() {
-  return combineCodec54(
+  return combineCodec53(
     getOpportunityMarketSponsorEncoder(),
     getOpportunityMarketSponsorDecoder()
   );
@@ -2399,22 +2370,22 @@ import {
   addEncoderSizePrefix as addEncoderSizePrefix2,
   assertAccountExists as assertAccountExists6,
   assertAccountsExist as assertAccountsExist6,
-  combineCodec as combineCodec55,
+  combineCodec as combineCodec54,
   decodeAccount as decodeAccount6,
   fetchEncodedAccount as fetchEncodedAccount6,
   fetchEncodedAccounts as fetchEncodedAccounts6,
   fixDecoderSize as fixDecoderSize6,
   fixEncoderSize as fixEncoderSize6,
-  getAddressDecoder as getAddressDecoder31,
-  getAddressEncoder as getAddressEncoder31,
+  getAddressDecoder as getAddressDecoder30,
+  getAddressEncoder as getAddressEncoder30,
   getBytesDecoder as getBytesDecoder6,
   getBytesEncoder as getBytesEncoder6,
-  getStructDecoder as getStructDecoder49,
-  getStructEncoder as getStructEncoder49,
-  getU32Decoder as getU32Decoder13,
-  getU32Encoder as getU32Encoder13,
-  getU64Decoder as getU64Decoder27,
-  getU64Encoder as getU64Encoder27,
+  getStructDecoder as getStructDecoder48,
+  getStructEncoder as getStructEncoder48,
+  getU32Decoder as getU32Decoder14,
+  getU32Encoder as getU32Encoder14,
+  getU64Decoder as getU64Decoder28,
+  getU64Encoder as getU64Encoder28,
   getU8Decoder as getU8Decoder19,
   getU8Encoder as getU8Encoder19,
   getUtf8Decoder as getUtf8Decoder2,
@@ -2438,37 +2409,37 @@ function getPlatformConfigDiscriminatorBytes() {
 }
 function getPlatformConfigEncoder() {
   return transformEncoder6(
-    getStructEncoder49([
+    getStructEncoder48([
       ["discriminator", fixEncoderSize6(getBytesEncoder6(), 8)],
       ["bump", getU8Encoder19()],
-      ["name", addEncoderSizePrefix2(getUtf8Encoder2(), getU32Encoder13())],
-      ["updateAuthority", getAddressEncoder31()],
-      ["feeClaimAuthority", getAddressEncoder31()],
+      ["name", addEncoderSizePrefix2(getUtf8Encoder2(), getU32Encoder14())],
+      ["updateAuthority", getAddressEncoder30()],
+      ["feeClaimAuthority", getAddressEncoder30()],
       ["feeRates", getFeeRatesEncoder()],
-      ["marketResolutionDeadlineSeconds", getU64Encoder27()],
-      ["minTimeToStakeSeconds", getU64Encoder27()],
-      ["minRevealPeriodSeconds", getU64Encoder27()],
-      ["maxRevealPeriodSeconds", getU64Encoder27()]
+      ["marketResolutionDeadlineSeconds", getU64Encoder28()],
+      ["minTimeToStakeSeconds", getU64Encoder28()],
+      ["revealAuthority", getAddressEncoder30()],
+      ["revealPeriodSeconds", getU64Encoder28()]
     ]),
     (value) => ({ ...value, discriminator: PLATFORM_CONFIG_DISCRIMINATOR })
   );
 }
 function getPlatformConfigDecoder() {
-  return getStructDecoder49([
+  return getStructDecoder48([
     ["discriminator", fixDecoderSize6(getBytesDecoder6(), 8)],
     ["bump", getU8Decoder19()],
-    ["name", addDecoderSizePrefix2(getUtf8Decoder2(), getU32Decoder13())],
-    ["updateAuthority", getAddressDecoder31()],
-    ["feeClaimAuthority", getAddressDecoder31()],
+    ["name", addDecoderSizePrefix2(getUtf8Decoder2(), getU32Decoder14())],
+    ["updateAuthority", getAddressDecoder30()],
+    ["feeClaimAuthority", getAddressDecoder30()],
     ["feeRates", getFeeRatesDecoder()],
-    ["marketResolutionDeadlineSeconds", getU64Decoder27()],
-    ["minTimeToStakeSeconds", getU64Decoder27()],
-    ["minRevealPeriodSeconds", getU64Decoder27()],
-    ["maxRevealPeriodSeconds", getU64Decoder27()]
+    ["marketResolutionDeadlineSeconds", getU64Decoder28()],
+    ["minTimeToStakeSeconds", getU64Decoder28()],
+    ["revealAuthority", getAddressDecoder30()],
+    ["revealPeriodSeconds", getU64Decoder28()]
   ]);
 }
 function getPlatformConfigCodec() {
-  return combineCodec55(getPlatformConfigEncoder(), getPlatformConfigDecoder());
+  return combineCodec54(getPlatformConfigEncoder(), getPlatformConfigDecoder());
 }
 function decodePlatformConfig(encodedAccount) {
   return decodeAccount6(
@@ -2505,30 +2476,30 @@ async function fetchAllMaybePlatformConfig(rpc, addresses, config) {
 import {
   assertAccountExists as assertAccountExists7,
   assertAccountsExist as assertAccountsExist7,
-  combineCodec as combineCodec56,
+  combineCodec as combineCodec55,
   decodeAccount as decodeAccount7,
   fetchEncodedAccount as fetchEncodedAccount7,
   fetchEncodedAccounts as fetchEncodedAccounts7,
   fixDecoderSize as fixDecoderSize7,
   fixEncoderSize as fixEncoderSize7,
-  getAddressDecoder as getAddressDecoder32,
-  getAddressEncoder as getAddressEncoder32,
+  getAddressDecoder as getAddressDecoder31,
+  getAddressEncoder as getAddressEncoder31,
   getArrayDecoder as getArrayDecoder13,
   getArrayEncoder as getArrayEncoder13,
-  getBooleanDecoder as getBooleanDecoder8,
-  getBooleanEncoder as getBooleanEncoder8,
+  getBooleanDecoder as getBooleanDecoder6,
+  getBooleanEncoder as getBooleanEncoder6,
   getBytesDecoder as getBytesDecoder7,
   getBytesEncoder as getBytesEncoder7,
   getOptionDecoder as getOptionDecoder6,
   getOptionEncoder as getOptionEncoder6,
-  getStructDecoder as getStructDecoder50,
-  getStructEncoder as getStructEncoder50,
+  getStructDecoder as getStructDecoder49,
+  getStructEncoder as getStructEncoder49,
   getU128Decoder as getU128Decoder5,
   getU128Encoder as getU128Encoder5,
-  getU32Decoder as getU32Decoder14,
-  getU32Encoder as getU32Encoder14,
-  getU64Decoder as getU64Decoder28,
-  getU64Encoder as getU64Encoder28,
+  getU32Decoder as getU32Decoder15,
+  getU32Encoder as getU32Encoder15,
+  getU64Decoder as getU64Decoder29,
+  getU64Encoder as getU64Encoder29,
   getU8Decoder as getU8Decoder20,
   getU8Encoder as getU8Encoder20,
   transformEncoder as transformEncoder7
@@ -2550,61 +2521,63 @@ function getStakeAccountDiscriminatorBytes() {
 }
 function getStakeAccountEncoder() {
   return transformEncoder7(
-    getStructEncoder50([
+    getStructEncoder49([
       ["discriminator", fixEncoderSize7(getBytesEncoder7(), 8)],
       ["encryptedOption", getArrayEncoder13(getU8Encoder20(), { size: 32 })],
       ["stateNonce", getU128Encoder5()],
       ["bump", getU8Encoder20()],
-      ["owner", getAddressEncoder32()],
-      ["market", getAddressEncoder32()],
+      ["owner", getAddressEncoder31()],
+      ["market", getAddressEncoder31()],
       ["userPubkey", getArrayEncoder13(getU8Encoder20(), { size: 32 })],
       [
         "encryptedOptionDisclosure",
         getArrayEncoder13(getU8Encoder20(), { size: 32 })
       ],
       ["stateNonceDisclosure", getU128Encoder5()],
-      ["stakedAtTimestamp", getOptionEncoder6(getU64Encoder28())],
-      ["unstakedAtTimestamp", getOptionEncoder6(getU64Encoder28())],
-      ["amount", getU64Encoder28()],
+      ["stakedAtTimestamp", getOptionEncoder6(getU64Encoder29())],
+      ["unstakedAtTimestamp", getOptionEncoder6(getU64Encoder29())],
+      ["amount", getU64Encoder29()],
       ["collectedFees", getCollectedFeesEncoder()],
-      ["revealedOption", getOptionEncoder6(getU64Encoder28())],
-      ["score", getOptionEncoder6(getU64Encoder28())],
-      ["unstaked", getBooleanEncoder8()],
-      ["id", getU32Encoder14()],
-      ["pendingStakeComputation", getOptionEncoder6(getAddressEncoder32())],
-      ["pendingReveal", getBooleanEncoder8()]
+      ["revealedOption", getOptionEncoder6(getU64Encoder29())],
+      ["score", getOptionEncoder6(getU64Encoder29())],
+      ["unstaked", getBooleanEncoder6()],
+      ["rewardsClaimed", getBooleanEncoder6()],
+      ["id", getU32Encoder15()],
+      ["pendingStakeComputation", getOptionEncoder6(getAddressEncoder31())],
+      ["pendingReveal", getBooleanEncoder6()]
     ]),
     (value) => ({ ...value, discriminator: STAKE_ACCOUNT_DISCRIMINATOR })
   );
 }
 function getStakeAccountDecoder() {
-  return getStructDecoder50([
+  return getStructDecoder49([
     ["discriminator", fixDecoderSize7(getBytesDecoder7(), 8)],
     ["encryptedOption", getArrayDecoder13(getU8Decoder20(), { size: 32 })],
     ["stateNonce", getU128Decoder5()],
     ["bump", getU8Decoder20()],
-    ["owner", getAddressDecoder32()],
-    ["market", getAddressDecoder32()],
+    ["owner", getAddressDecoder31()],
+    ["market", getAddressDecoder31()],
     ["userPubkey", getArrayDecoder13(getU8Decoder20(), { size: 32 })],
     [
       "encryptedOptionDisclosure",
       getArrayDecoder13(getU8Decoder20(), { size: 32 })
     ],
     ["stateNonceDisclosure", getU128Decoder5()],
-    ["stakedAtTimestamp", getOptionDecoder6(getU64Decoder28())],
-    ["unstakedAtTimestamp", getOptionDecoder6(getU64Decoder28())],
-    ["amount", getU64Decoder28()],
+    ["stakedAtTimestamp", getOptionDecoder6(getU64Decoder29())],
+    ["unstakedAtTimestamp", getOptionDecoder6(getU64Decoder29())],
+    ["amount", getU64Decoder29()],
     ["collectedFees", getCollectedFeesDecoder()],
-    ["revealedOption", getOptionDecoder6(getU64Decoder28())],
-    ["score", getOptionDecoder6(getU64Decoder28())],
-    ["unstaked", getBooleanDecoder8()],
-    ["id", getU32Decoder14()],
-    ["pendingStakeComputation", getOptionDecoder6(getAddressDecoder32())],
-    ["pendingReveal", getBooleanDecoder8()]
+    ["revealedOption", getOptionDecoder6(getU64Decoder29())],
+    ["score", getOptionDecoder6(getU64Decoder29())],
+    ["unstaked", getBooleanDecoder6()],
+    ["rewardsClaimed", getBooleanDecoder6()],
+    ["id", getU32Decoder15()],
+    ["pendingStakeComputation", getOptionDecoder6(getAddressDecoder31())],
+    ["pendingReveal", getBooleanDecoder6()]
   ]);
 }
 function getStakeAccountCodec() {
-  return combineCodec56(getStakeAccountEncoder(), getStakeAccountDecoder());
+  return combineCodec55(getStakeAccountEncoder(), getStakeAccountDecoder());
 }
 function decodeStakeAccount(encodedAccount) {
   return decodeAccount7(
@@ -2642,7 +2615,7 @@ import {
   fixEncoderSize as fixEncoderSize8,
   getBytesEncoder as getBytesEncoder8
 } from "@solana/kit";
-var OPPORTUNITY_MARKET_PROGRAM_ADDRESS = "B3NCHsGBkdZrPYPJY2rjg4UwmyRotMmFWhxa5hMHwLeg";
+var OPPORTUNITY_MARKET_PROGRAM_ADDRESS = "bncqApu6NkUibDwnbfXR5oRPCLiYjwHgVuCdHRTD6rp";
 var OpportunityMarketAccount = /* @__PURE__ */ ((OpportunityMarketAccount2) => {
   OpportunityMarketAccount2[OpportunityMarketAccount2["AllowedMint"] = 0] = "AllowedMint";
   OpportunityMarketAccount2[OpportunityMarketAccount2["ArciumSignerAccount"] = 1] = "ArciumSignerAccount";
@@ -2727,19 +2700,19 @@ var OpportunityMarketInstruction = /* @__PURE__ */ ((OpportunityMarketInstructio
   OpportunityMarketInstruction2[OpportunityMarketInstruction2["AddReward"] = 1] = "AddReward";
   OpportunityMarketInstruction2[OpportunityMarketInstruction2["ClaimCreatorFees"] = 2] = "ClaimCreatorFees";
   OpportunityMarketInstruction2[OpportunityMarketInstruction2["ClaimFees"] = 3] = "ClaimFees";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["CloseOptionAccount"] = 4] = "CloseOptionAccount";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["CloseStakeAccount"] = 5] = "CloseStakeAccount";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["CloseStuckStakeAccount"] = 6] = "CloseStuckStakeAccount";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["CreateMarket"] = 7] = "CreateMarket";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["EndRevealPeriod"] = 8] = "EndRevealPeriod";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["FinalizeRevealStake"] = 9] = "FinalizeRevealStake";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["InitAllowedMint"] = 10] = "InitAllowedMint";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["InitPlatformConfig"] = 11] = "InitPlatformConfig";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["InitStakeAccount"] = 12] = "InitStakeAccount";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["OpenMarket"] = 13] = "OpenMarket";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["PauseStaking"] = 14] = "PauseStaking";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["ResolveMarket"] = 15] = "ResolveMarket";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["ResumeStaking"] = 16] = "ResumeStaking";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["ClaimRewards"] = 4] = "ClaimRewards";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["CloseOptionAccount"] = 5] = "CloseOptionAccount";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["CloseStakeAccount"] = 6] = "CloseStakeAccount";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["CloseStuckStakeAccount"] = 7] = "CloseStuckStakeAccount";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["CloseUnrevealedStakeAccount"] = 8] = "CloseUnrevealedStakeAccount";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["CreateMarket"] = 9] = "CreateMarket";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["EndRevealPeriod"] = 10] = "EndRevealPeriod";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["FinalizeRevealStake"] = 11] = "FinalizeRevealStake";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["InitAllowedMint"] = 12] = "InitAllowedMint";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["InitPlatformConfig"] = 13] = "InitPlatformConfig";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["InitStakeAccount"] = 14] = "InitStakeAccount";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["OpenMarket"] = 15] = "OpenMarket";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["ResolveMarket"] = 16] = "ResolveMarket";
   OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealStake"] = 17] = "RevealStake";
   OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealStakeCallback"] = 18] = "RevealStakeCallback";
   OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealStakeCompDef"] = 19] = "RevealStakeCompDef";
@@ -2795,119 +2768,119 @@ function identifyOpportunityMarketInstruction(instruction) {
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([46, 121, 107, 240, 123, 190, 229, 1])
+      new Uint8Array([4, 144, 132, 71, 116, 23, 151, 80])
     ),
     0
   )) {
-    return 4 /* CloseOptionAccount */;
+    return 4 /* ClaimRewards */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([246, 236, 59, 167, 115, 135, 122, 12])
+      new Uint8Array([46, 121, 107, 240, 123, 190, 229, 1])
     ),
     0
   )) {
-    return 5 /* CloseStakeAccount */;
+    return 5 /* CloseOptionAccount */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([41, 239, 108, 203, 185, 230, 165, 181])
+      new Uint8Array([246, 236, 59, 167, 115, 135, 122, 12])
     ),
     0
   )) {
-    return 6 /* CloseStuckStakeAccount */;
+    return 6 /* CloseStakeAccount */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([103, 226, 97, 235, 200, 188, 251, 254])
+      new Uint8Array([41, 239, 108, 203, 185, 230, 165, 181])
     ),
     0
   )) {
-    return 7 /* CreateMarket */;
+    return 7 /* CloseStuckStakeAccount */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([144, 81, 42, 65, 127, 60, 134, 92])
+      new Uint8Array([171, 229, 236, 216, 122, 118, 188, 103])
     ),
     0
   )) {
-    return 8 /* EndRevealPeriod */;
+    return 8 /* CloseUnrevealedStakeAccount */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([92, 201, 94, 219, 117, 53, 255, 230])
+      new Uint8Array([103, 226, 97, 235, 200, 188, 251, 254])
     ),
     0
   )) {
-    return 9 /* FinalizeRevealStake */;
+    return 9 /* CreateMarket */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([215, 70, 3, 5, 42, 229, 151, 10])
+      new Uint8Array([144, 81, 42, 65, 127, 60, 134, 92])
     ),
     0
   )) {
-    return 10 /* InitAllowedMint */;
+    return 10 /* EndRevealPeriod */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([101, 52, 47, 49, 156, 16, 32, 118])
+      new Uint8Array([92, 201, 94, 219, 117, 53, 255, 230])
     ),
     0
   )) {
-    return 11 /* InitPlatformConfig */;
+    return 11 /* FinalizeRevealStake */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([132, 171, 255, 149, 163, 37, 220, 45])
+      new Uint8Array([215, 70, 3, 5, 42, 229, 151, 10])
     ),
     0
   )) {
-    return 12 /* InitStakeAccount */;
+    return 12 /* InitAllowedMint */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([116, 19, 123, 75, 217, 244, 69, 44])
+      new Uint8Array([101, 52, 47, 49, 156, 16, 32, 118])
     ),
     0
   )) {
-    return 13 /* OpenMarket */;
+    return 13 /* InitPlatformConfig */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([245, 191, 35, 58, 88, 250, 229, 60])
+      new Uint8Array([132, 171, 255, 149, 163, 37, 220, 45])
     ),
     0
   )) {
-    return 14 /* PauseStaking */;
+    return 14 /* InitStakeAccount */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([155, 23, 80, 173, 46, 74, 23, 239])
+      new Uint8Array([116, 19, 123, 75, 217, 244, 69, 44])
     ),
     0
   )) {
-    return 15 /* ResolveMarket */;
+    return 15 /* OpenMarket */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([31, 200, 175, 23, 211, 22, 63, 155])
+      new Uint8Array([155, 23, 80, 173, 46, 74, 23, 239])
     ),
     0
   )) {
-    return 16 /* ResumeStaking */;
+    return 16 /* ResolveMarket */;
   }
   if (containsBytes(
     data,
@@ -3049,16 +3022,15 @@ var OPPORTUNITY_MARKET_ERROR__LOCKED = 6022;
 var OPPORTUNITY_MARKET_ERROR__INVALID_ACCOUNT_STATE = 6023;
 var OPPORTUNITY_MARKET_ERROR__NO_FEES_TO_CLAIM = 6024;
 var OPPORTUNITY_MARKET_ERROR__STAKE_NOT_STUCK = 6025;
-var OPPORTUNITY_MARKET_ERROR__MARKET_PAUSED = 6026;
-var OPPORTUNITY_MARKET_ERROR__MARKET_NOT_PAUSED = 6027;
-var OPPORTUNITY_MARKET_ERROR__STAKE_BELOW_MINIMUM = 6028;
-var OPPORTUNITY_MARKET_ERROR__SELECT_OPTIONS_DEADLINE_PASSED = 6029;
-var OPPORTUNITY_MARKET_ERROR__INVALID_FEE_RATES = 6030;
-var OPPORTUNITY_MARKET_ERROR__OPTION_STILL_NEEDED = 6031;
-var OPPORTUNITY_MARKET_ERROR__CREATOR_MISMATCH = 6032;
-var OPPORTUNITY_MARKET_ERROR__REVEAL_PERIOD_NOT_OVER = 6033;
-var OPPORTUNITY_MARKET_ERROR__NO_REWARD_TO_CLAIM = 6034;
-var OPPORTUNITY_MARKET_ERROR__REWARD_ALREADY_CLAIMED = 6035;
+var OPPORTUNITY_MARKET_ERROR__STAKE_BELOW_MINIMUM = 6026;
+var OPPORTUNITY_MARKET_ERROR__SELECT_OPTIONS_DEADLINE_PASSED = 6027;
+var OPPORTUNITY_MARKET_ERROR__INVALID_FEE_RATES = 6028;
+var OPPORTUNITY_MARKET_ERROR__OPTION_STILL_NEEDED = 6029;
+var OPPORTUNITY_MARKET_ERROR__CREATOR_MISMATCH = 6030;
+var OPPORTUNITY_MARKET_ERROR__REVEAL_PERIOD_NOT_OVER = 6031;
+var OPPORTUNITY_MARKET_ERROR__NO_FINALIZED_WINNING_OPTION = 6032;
+var OPPORTUNITY_MARKET_ERROR__NO_REWARD_TO_CLAIM = 6033;
+var OPPORTUNITY_MARKET_ERROR__REWARD_ALREADY_CLAIMED = 6034;
 var opportunityMarketErrorMessages;
 if (true) {
   opportunityMarketErrorMessages = {
@@ -3079,10 +3051,9 @@ 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__NO_FINALIZED_WINNING_OPTION]: `No winning option has a finalized stake`,
     [OPPORTUNITY_MARKET_ERROR__NO_REWARD_TO_CLAIM]: `No reward to claim`,
     [OPPORTUNITY_MARKET_ERROR__NO_STAKE]: `Stake account has no recorded stake`,
     [OPPORTUNITY_MARKET_ERROR__NOT_REVEALED]: `Stake not yet revealed`,
@@ -3117,17 +3088,17 @@ function isOpportunityMarketError(error, transactionMessage, code) {
 
 // src/generated/instructions/addMarketOption.ts
 import {
-  combineCodec as combineCodec57,
+  combineCodec as combineCodec56,
   fixDecoderSize as fixDecoderSize8,
   fixEncoderSize as fixEncoderSize9,
-  getAddressEncoder as getAddressEncoder33,
+  getAddressEncoder as getAddressEncoder32,
   getBytesDecoder as getBytesDecoder8,
   getBytesEncoder as getBytesEncoder9,
   getProgramDerivedAddress,
-  getStructDecoder as getStructDecoder51,
-  getStructEncoder as getStructEncoder51,
-  getU64Decoder as getU64Decoder29,
-  getU64Encoder as getU64Encoder29,
+  getStructDecoder as getStructDecoder50,
+  getStructEncoder as getStructEncoder50,
+  getU64Decoder as getU64Decoder30,
+  getU64Encoder as getU64Encoder30,
   transformEncoder as transformEncoder8
 } from "@solana/kit";
 
@@ -3195,21 +3166,21 @@ function getAddMarketOptionDiscriminatorBytes() {
 }
 function getAddMarketOptionInstructionDataEncoder() {
   return transformEncoder8(
-    getStructEncoder51([
+    getStructEncoder50([
       ["discriminator", fixEncoderSize9(getBytesEncoder9(), 8)],
-      ["optionId", getU64Encoder29()]
+      ["optionId", getU64Encoder30()]
     ]),
     (value) => ({ ...value, discriminator: ADD_MARKET_OPTION_DISCRIMINATOR })
   );
 }
 function getAddMarketOptionInstructionDataDecoder() {
-  return getStructDecoder51([
+  return getStructDecoder50([
     ["discriminator", fixDecoderSize8(getBytesDecoder8(), 8)],
-    ["optionId", getU64Decoder29()]
+    ["optionId", getU64Decoder30()]
   ]);
 }
 function getAddMarketOptionInstructionDataCodec() {
-  return combineCodec57(
+  return combineCodec56(
     getAddMarketOptionInstructionDataEncoder(),
     getAddMarketOptionInstructionDataDecoder()
   );
@@ -3231,8 +3202,8 @@ async function getAddMarketOptionInstructionAsync(input, config) {
         getBytesEncoder9().encode(
           new Uint8Array([111, 112, 116, 105, 111, 110])
         ),
-        getAddressEncoder33().encode(expectAddress(accounts.market.value)),
-        getU64Encoder29().encode(expectSome(args.optionId))
+        getAddressEncoder32().encode(expectAddress(accounts.market.value)),
+        getU64Encoder30().encode(expectSome(args.optionId))
       ]
     });
   }
@@ -3304,19 +3275,17 @@ function parseAddMarketOptionInstruction(instruction) {
 
 // src/generated/instructions/addReward.ts
 import {
-  combineCodec as combineCodec58,
+  combineCodec as combineCodec57,
   fixDecoderSize as fixDecoderSize9,
   fixEncoderSize as fixEncoderSize10,
-  getAddressEncoder as getAddressEncoder34,
-  getBooleanDecoder as getBooleanDecoder9,
-  getBooleanEncoder as getBooleanEncoder9,
+  getAddressEncoder as getAddressEncoder33,
   getBytesDecoder as getBytesDecoder9,
   getBytesEncoder as getBytesEncoder10,
   getProgramDerivedAddress as getProgramDerivedAddress2,
-  getStructDecoder as getStructDecoder52,
-  getStructEncoder as getStructEncoder52,
-  getU64Decoder as getU64Decoder30,
-  getU64Encoder as getU64Encoder30,
+  getStructDecoder as getStructDecoder51,
+  getStructEncoder as getStructEncoder51,
+  getU64Decoder as getU64Decoder31,
+  getU64Encoder as getU64Encoder31,
   transformEncoder as transformEncoder9
 } from "@solana/kit";
 var ADD_REWARD_DISCRIMINATOR = new Uint8Array([
@@ -3334,23 +3303,21 @@ function getAddRewardDiscriminatorBytes() {
 }
 function getAddRewardInstructionDataEncoder() {
   return transformEncoder9(
-    getStructEncoder52([
+    getStructEncoder51([
       ["discriminator", fixEncoderSize10(getBytesEncoder10(), 8)],
-      ["amount", getU64Encoder30()],
-      ["lock", getBooleanEncoder9()]
+      ["amount", getU64Encoder31()]
     ]),
     (value) => ({ ...value, discriminator: ADD_REWARD_DISCRIMINATOR })
   );
 }
 function getAddRewardInstructionDataDecoder() {
-  return getStructDecoder52([
+  return getStructDecoder51([
     ["discriminator", fixDecoderSize9(getBytesDecoder9(), 8)],
-    ["amount", getU64Decoder30()],
-    ["lock", getBooleanDecoder9()]
+    ["amount", getU64Decoder31()]
   ]);
 }
 function getAddRewardInstructionDataCodec() {
-  return combineCodec58(
+  return combineCodec57(
     getAddRewardInstructionDataEncoder(),
     getAddRewardInstructionDataDecoder()
   );
@@ -3379,8 +3346,8 @@ async function getAddRewardInstructionAsync(input, config) {
         getBytesEncoder10().encode(
           new Uint8Array([115, 112, 111, 110, 115, 111, 114])
         ),
-        getAddressEncoder34().encode(expectAddress(accounts.sponsor.value)),
-        getAddressEncoder34().encode(expectAddress(accounts.market.value))
+        getAddressEncoder33().encode(expectAddress(accounts.sponsor.value)),
+        getAddressEncoder33().encode(expectAddress(accounts.market.value))
       ]
     });
   }
@@ -3388,9 +3355,9 @@ async function getAddRewardInstructionAsync(input, config) {
     accounts.marketTokenAta.value = await getProgramDerivedAddress2({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder34().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder34().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder34().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder33().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder33().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder33().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -3481,15 +3448,15 @@ function parseAddRewardInstruction(instruction) {
 
 // src/generated/instructions/claimCreatorFees.ts
 import {
-  combineCodec as combineCodec59,
+  combineCodec as combineCodec58,
   fixDecoderSize as fixDecoderSize10,
   fixEncoderSize as fixEncoderSize11,
-  getAddressEncoder as getAddressEncoder35,
+  getAddressEncoder as getAddressEncoder34,
   getBytesDecoder as getBytesDecoder10,
   getBytesEncoder as getBytesEncoder11,
   getProgramDerivedAddress as getProgramDerivedAddress3,
-  getStructDecoder as getStructDecoder53,
-  getStructEncoder as getStructEncoder53,
+  getStructDecoder as getStructDecoder52,
+  getStructEncoder as getStructEncoder52,
   transformEncoder as transformEncoder10
 } from "@solana/kit";
 var CLAIM_CREATOR_FEES_DISCRIMINATOR = new Uint8Array([
@@ -3509,17 +3476,17 @@ function getClaimCreatorFeesDiscriminatorBytes() {
 }
 function getClaimCreatorFeesInstructionDataEncoder() {
   return transformEncoder10(
-    getStructEncoder53([["discriminator", fixEncoderSize11(getBytesEncoder11(), 8)]]),
+    getStructEncoder52([["discriminator", fixEncoderSize11(getBytesEncoder11(), 8)]]),
     (value) => ({ ...value, discriminator: CLAIM_CREATOR_FEES_DISCRIMINATOR })
   );
 }
 function getClaimCreatorFeesInstructionDataDecoder() {
-  return getStructDecoder53([
+  return getStructDecoder52([
     ["discriminator", fixDecoderSize10(getBytesDecoder10(), 8)]
   ]);
 }
 function getClaimCreatorFeesInstructionDataCodec() {
-  return combineCodec59(
+  return combineCodec58(
     getClaimCreatorFeesInstructionDataEncoder(),
     getClaimCreatorFeesInstructionDataDecoder()
   );
@@ -3542,9 +3509,9 @@ async function getClaimCreatorFeesInstructionAsync(input, config) {
     accounts.marketTokenAta.value = await getProgramDerivedAddress3({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder35().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder35().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder35().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder34().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder34().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder34().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -3616,15 +3583,15 @@ function parseClaimCreatorFeesInstruction(instruction) {
 
 // src/generated/instructions/claimFees.ts
 import {
-  combineCodec as combineCodec60,
+  combineCodec as combineCodec59,
   fixDecoderSize as fixDecoderSize11,
   fixEncoderSize as fixEncoderSize12,
-  getAddressEncoder as getAddressEncoder36,
+  getAddressEncoder as getAddressEncoder35,
   getBytesDecoder as getBytesDecoder11,
   getBytesEncoder as getBytesEncoder12,
   getProgramDerivedAddress as getProgramDerivedAddress4,
-  getStructDecoder as getStructDecoder54,
-  getStructEncoder as getStructEncoder54,
+  getStructDecoder as getStructDecoder53,
+  getStructEncoder as getStructEncoder53,
   transformEncoder as transformEncoder11
 } from "@solana/kit";
 var CLAIM_FEES_DISCRIMINATOR = new Uint8Array([
@@ -3642,17 +3609,17 @@ function getClaimFeesDiscriminatorBytes() {
 }
 function getClaimFeesInstructionDataEncoder() {
   return transformEncoder11(
-    getStructEncoder54([["discriminator", fixEncoderSize12(getBytesEncoder12(), 8)]]),
+    getStructEncoder53([["discriminator", fixEncoderSize12(getBytesEncoder12(), 8)]]),
     (value) => ({ ...value, discriminator: CLAIM_FEES_DISCRIMINATOR })
   );
 }
 function getClaimFeesInstructionDataDecoder() {
-  return getStructDecoder54([
+  return getStructDecoder53([
     ["discriminator", fixDecoderSize11(getBytesDecoder11(), 8)]
   ]);
 }
 function getClaimFeesInstructionDataCodec() {
-  return combineCodec60(
+  return combineCodec59(
     getClaimFeesInstructionDataEncoder(),
     getClaimFeesInstructionDataDecoder()
   );
@@ -3676,9 +3643,9 @@ async function getClaimFeesInstructionAsync(input, config) {
     accounts.marketTokenAta.value = await getProgramDerivedAddress4({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder36().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder36().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder36().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder35().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder35().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder35().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -3752,20 +3719,165 @@ function parseClaimFeesInstruction(instruction) {
   };
 }
 
-// src/generated/instructions/closeOptionAccount.ts
+// src/generated/instructions/claimRewards.ts
 import {
-  combineCodec as combineCodec61,
+  combineCodec as combineCodec60,
   fixDecoderSize as fixDecoderSize12,
   fixEncoderSize as fixEncoderSize13,
-  getAddressEncoder as getAddressEncoder37,
+  getAddressEncoder as getAddressEncoder36,
   getBytesDecoder as getBytesDecoder12,
   getBytesEncoder as getBytesEncoder13,
   getProgramDerivedAddress as getProgramDerivedAddress5,
+  getStructDecoder as getStructDecoder54,
+  getStructEncoder as getStructEncoder54,
+  transformEncoder as transformEncoder12
+} from "@solana/kit";
+var CLAIM_REWARDS_DISCRIMINATOR = new Uint8Array([
+  4,
+  144,
+  132,
+  71,
+  116,
+  23,
+  151,
+  80
+]);
+function getClaimRewardsDiscriminatorBytes() {
+  return fixEncoderSize13(getBytesEncoder13(), 8).encode(
+    CLAIM_REWARDS_DISCRIMINATOR
+  );
+}
+function getClaimRewardsInstructionDataEncoder() {
+  return transformEncoder12(
+    getStructEncoder54([["discriminator", fixEncoderSize13(getBytesEncoder13(), 8)]]),
+    (value) => ({ ...value, discriminator: CLAIM_REWARDS_DISCRIMINATOR })
+  );
+}
+function getClaimRewardsInstructionDataDecoder() {
+  return getStructDecoder54([
+    ["discriminator", fixDecoderSize12(getBytesDecoder12(), 8)]
+  ]);
+}
+function getClaimRewardsInstructionDataCodec() {
+  return combineCodec60(
+    getClaimRewardsInstructionDataEncoder(),
+    getClaimRewardsInstructionDataDecoder()
+  );
+}
+async function getClaimRewardsInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    owner: { value: input.owner ?? null, isWritable: true },
+    market: { value: input.market ?? null, isWritable: true },
+    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
+    option: { value: input.option ?? null, isWritable: true },
+    tokenMint: { value: input.tokenMint ?? null, isWritable: false },
+    marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
+    ownerTokenAccount: {
+      value: input.ownerTokenAccount ?? null,
+      isWritable: true
+    },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.marketTokenAta.value) {
+    accounts.marketTokenAta.value = await getProgramDerivedAddress5({
+      programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+      seeds: [
+        getAddressEncoder36().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder36().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder36().encode(expectAddress(accounts.tokenMint.value))
+      ]
+    });
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.owner),
+      getAccountMeta(accounts.market),
+      getAccountMeta(accounts.stakeAccount),
+      getAccountMeta(accounts.option),
+      getAccountMeta(accounts.tokenMint),
+      getAccountMeta(accounts.marketTokenAta),
+      getAccountMeta(accounts.ownerTokenAccount),
+      getAccountMeta(accounts.tokenProgram)
+    ],
+    data: getClaimRewardsInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function getClaimRewardsInstruction(input, config) {
+  const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    owner: { value: input.owner ?? null, isWritable: true },
+    market: { value: input.market ?? null, isWritable: true },
+    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
+    option: { value: input.option ?? null, isWritable: true },
+    tokenMint: { value: input.tokenMint ?? null, isWritable: false },
+    marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
+    ownerTokenAccount: {
+      value: input.ownerTokenAccount ?? null,
+      isWritable: true
+    },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.owner),
+      getAccountMeta(accounts.market),
+      getAccountMeta(accounts.stakeAccount),
+      getAccountMeta(accounts.option),
+      getAccountMeta(accounts.tokenMint),
+      getAccountMeta(accounts.marketTokenAta),
+      getAccountMeta(accounts.ownerTokenAccount),
+      getAccountMeta(accounts.tokenProgram)
+    ],
+    data: getClaimRewardsInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseClaimRewardsInstruction(instruction) {
+  if (instruction.accounts.length < 8) {
+    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: {
+      owner: getNextAccount(),
+      market: getNextAccount(),
+      stakeAccount: getNextAccount(),
+      option: getNextAccount(),
+      tokenMint: getNextAccount(),
+      marketTokenAta: getNextAccount(),
+      ownerTokenAccount: getNextAccount(),
+      tokenProgram: getNextAccount()
+    },
+    data: getClaimRewardsInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/generated/instructions/closeOptionAccount.ts
+import {
+  combineCodec as combineCodec61,
+  fixDecoderSize as fixDecoderSize13,
+  fixEncoderSize as fixEncoderSize14,
+  getAddressEncoder as getAddressEncoder37,
+  getBytesDecoder as getBytesDecoder13,
+  getBytesEncoder as getBytesEncoder14,
+  getProgramDerivedAddress as getProgramDerivedAddress6,
   getStructDecoder as getStructDecoder55,
   getStructEncoder as getStructEncoder55,
-  getU64Decoder as getU64Decoder31,
-  getU64Encoder as getU64Encoder31,
-  transformEncoder as transformEncoder12
+  getU64Decoder as getU64Decoder32,
+  getU64Encoder as getU64Encoder32,
+  transformEncoder as transformEncoder13
 } from "@solana/kit";
 var CLOSE_OPTION_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   46,
@@ -3778,23 +3890,23 @@ var CLOSE_OPTION_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   1
 ]);
 function getCloseOptionAccountDiscriminatorBytes() {
-  return fixEncoderSize13(getBytesEncoder13(), 8).encode(
+  return fixEncoderSize14(getBytesEncoder14(), 8).encode(
     CLOSE_OPTION_ACCOUNT_DISCRIMINATOR
   );
 }
 function getCloseOptionAccountInstructionDataEncoder() {
-  return transformEncoder12(
+  return transformEncoder13(
     getStructEncoder55([
-      ["discriminator", fixEncoderSize13(getBytesEncoder13(), 8)],
-      ["optionId", getU64Encoder31()]
+      ["discriminator", fixEncoderSize14(getBytesEncoder14(), 8)],
+      ["optionId", getU64Encoder32()]
     ]),
     (value) => ({ ...value, discriminator: CLOSE_OPTION_ACCOUNT_DISCRIMINATOR })
   );
 }
 function getCloseOptionAccountInstructionDataDecoder() {
   return getStructDecoder55([
-    ["discriminator", fixDecoderSize12(getBytesDecoder12(), 8)],
-    ["optionId", getU64Decoder31()]
+    ["discriminator", fixDecoderSize13(getBytesDecoder13(), 8)],
+    ["optionId", getU64Decoder32()]
   ]);
 }
 function getCloseOptionAccountInstructionDataCodec() {
@@ -3815,14 +3927,14 @@ async function getCloseOptionAccountInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.option.value) {
-    accounts.option.value = await getProgramDerivedAddress5({
+    accounts.option.value = await getProgramDerivedAddress6({
       programAddress,
       seeds: [
-        getBytesEncoder13().encode(
+        getBytesEncoder14().encode(
           new Uint8Array([111, 112, 116, 105, 111, 110])
         ),
         getAddressEncoder37().encode(expectAddress(accounts.market.value)),
-        getU64Encoder31().encode(expectSome(args.optionId))
+        getU64Encoder32().encode(expectSome(args.optionId))
       ]
     });
   }
@@ -3901,19 +4013,15 @@ function parseCloseOptionAccountInstruction(instruction) {
 // src/generated/instructions/closeStakeAccount.ts
 import {
   combineCodec as combineCodec62,
-  fixDecoderSize as fixDecoderSize13,
-  fixEncoderSize as fixEncoderSize14,
+  fixDecoderSize as fixDecoderSize14,
+  fixEncoderSize as fixEncoderSize15,
   getAddressEncoder as getAddressEncoder38,
-  getBytesDecoder as getBytesDecoder13,
-  getBytesEncoder as getBytesEncoder14,
-  getProgramDerivedAddress as getProgramDerivedAddress6,
+  getBytesDecoder as getBytesDecoder14,
+  getBytesEncoder as getBytesEncoder15,
+  getProgramDerivedAddress as getProgramDerivedAddress7,
   getStructDecoder as getStructDecoder56,
   getStructEncoder as getStructEncoder56,
-  getU32Decoder as getU32Decoder15,
-  getU32Encoder as getU32Encoder15,
-  getU64Decoder as getU64Decoder32,
-  getU64Encoder as getU64Encoder32,
-  transformEncoder as transformEncoder13
+  transformEncoder as transformEncoder14
 } from "@solana/kit";
 var CLOSE_STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   246,
@@ -3926,25 +4034,19 @@ var CLOSE_STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   12
 ]);
 function getCloseStakeAccountDiscriminatorBytes() {
-  return fixEncoderSize14(getBytesEncoder14(), 8).encode(
+  return fixEncoderSize15(getBytesEncoder15(), 8).encode(
     CLOSE_STAKE_ACCOUNT_DISCRIMINATOR
   );
 }
 function getCloseStakeAccountInstructionDataEncoder() {
-  return transformEncoder13(
-    getStructEncoder56([
-      ["discriminator", fixEncoderSize14(getBytesEncoder14(), 8)],
-      ["optionId", getU64Encoder32()],
-      ["stakeAccountId", getU32Encoder15()]
-    ]),
+  return transformEncoder14(
+    getStructEncoder56([["discriminator", fixEncoderSize15(getBytesEncoder15(), 8)]]),
     (value) => ({ ...value, discriminator: CLOSE_STAKE_ACCOUNT_DISCRIMINATOR })
   );
 }
 function getCloseStakeAccountInstructionDataDecoder() {
   return getStructDecoder56([
-    ["discriminator", fixDecoderSize13(getBytesDecoder13(), 8)],
-    ["optionId", getU64Decoder32()],
-    ["stakeAccountId", getU32Decoder15()]
+    ["discriminator", fixDecoderSize14(getBytesDecoder14(), 8)]
   ]);
 }
 function getCloseStakeAccountInstructionDataCodec() {
@@ -3970,48 +4072,8 @@ async function getCloseStakeAccountInstructionAsync(input, config) {
     systemProgram: { value: input.systemProgram ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
-  const args = { ...input };
-  if (!accounts.stakeAccount.value) {
-    accounts.stakeAccount.value = await getProgramDerivedAddress6({
-      programAddress,
-      seeds: [
-        getBytesEncoder14().encode(
-          new Uint8Array([
-            115,
-            116,
-            97,
-            107,
-            101,
-            95,
-            97,
-            99,
-            99,
-            111,
-            117,
-            110,
-            116
-          ])
-        ),
-        getAddressEncoder38().encode(expectAddress(accounts.owner.value)),
-        getAddressEncoder38().encode(expectAddress(accounts.market.value)),
-        getU32Encoder15().encode(expectSome(args.stakeAccountId))
-      ]
-    });
-  }
-  if (!accounts.option.value) {
-    accounts.option.value = await getProgramDerivedAddress6({
-      programAddress,
-      seeds: [
-        getBytesEncoder14().encode(
-          new Uint8Array([111, 112, 116, 105, 111, 110])
-        ),
-        getAddressEncoder38().encode(expectAddress(accounts.market.value)),
-        getU64Encoder32().encode(expectSome(args.optionId))
-      ]
-    });
-  }
   if (!accounts.marketTokenAta.value) {
-    accounts.marketTokenAta.value = await getProgramDerivedAddress6({
+    accounts.marketTokenAta.value = await getProgramDerivedAddress7({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
         getAddressEncoder38().encode(expectAddress(accounts.market.value)),
@@ -4036,9 +4098,7 @@ async function getCloseStakeAccountInstructionAsync(input, config) {
       getAccountMeta(accounts.tokenProgram),
       getAccountMeta(accounts.systemProgram)
     ],
-    data: getCloseStakeAccountInstructionDataEncoder().encode(
-      args
-    ),
+    data: getCloseStakeAccountInstructionDataEncoder().encode({}),
     programAddress
   });
 }
@@ -4059,7 +4119,6 @@ function getCloseStakeAccountInstruction(input, config) {
     systemProgram: { value: input.systemProgram ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
-  const args = { ...input };
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
@@ -4076,9 +4135,7 @@ function getCloseStakeAccountInstruction(input, config) {
       getAccountMeta(accounts.tokenProgram),
       getAccountMeta(accounts.systemProgram)
     ],
-    data: getCloseStakeAccountInstructionDataEncoder().encode(
-      args
-    ),
+    data: getCloseStakeAccountInstructionDataEncoder().encode({}),
     programAddress
   });
 }
@@ -4112,17 +4169,17 @@ function parseCloseStakeAccountInstruction(instruction) {
 // src/generated/instructions/closeStuckStakeAccount.ts
 import {
   combineCodec as combineCodec63,
-  fixDecoderSize as fixDecoderSize14,
-  fixEncoderSize as fixEncoderSize15,
+  fixDecoderSize as fixDecoderSize15,
+  fixEncoderSize as fixEncoderSize16,
   getAddressEncoder as getAddressEncoder39,
-  getBytesDecoder as getBytesDecoder14,
-  getBytesEncoder as getBytesEncoder15,
-  getProgramDerivedAddress as getProgramDerivedAddress7,
+  getBytesDecoder as getBytesDecoder15,
+  getBytesEncoder as getBytesEncoder16,
+  getProgramDerivedAddress as getProgramDerivedAddress8,
   getStructDecoder as getStructDecoder57,
   getStructEncoder as getStructEncoder57,
   getU32Decoder as getU32Decoder16,
   getU32Encoder as getU32Encoder16,
-  transformEncoder as transformEncoder14
+  transformEncoder as transformEncoder15
 } from "@solana/kit";
 var CLOSE_STUCK_STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   41,
@@ -4135,14 +4192,14 @@ var CLOSE_STUCK_STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   181
 ]);
 function getCloseStuckStakeAccountDiscriminatorBytes() {
-  return fixEncoderSize15(getBytesEncoder15(), 8).encode(
+  return fixEncoderSize16(getBytesEncoder16(), 8).encode(
     CLOSE_STUCK_STAKE_ACCOUNT_DISCRIMINATOR
   );
 }
 function getCloseStuckStakeAccountInstructionDataEncoder() {
-  return transformEncoder14(
+  return transformEncoder15(
     getStructEncoder57([
-      ["discriminator", fixEncoderSize15(getBytesEncoder15(), 8)],
+      ["discriminator", fixEncoderSize16(getBytesEncoder16(), 8)],
       ["stakeAccountId", getU32Encoder16()]
     ]),
     (value) => ({
@@ -4153,7 +4210,7 @@ function getCloseStuckStakeAccountInstructionDataEncoder() {
 }
 function getCloseStuckStakeAccountInstructionDataDecoder() {
   return getStructDecoder57([
-    ["discriminator", fixDecoderSize14(getBytesDecoder14(), 8)],
+    ["discriminator", fixDecoderSize15(getBytesDecoder15(), 8)],
     ["stakeAccountId", getU32Decoder16()]
   ]);
 }
@@ -4181,10 +4238,10 @@ async function getCloseStuckStakeAccountInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.stakeAccount.value) {
-    accounts.stakeAccount.value = await getProgramDerivedAddress7({
+    accounts.stakeAccount.value = await getProgramDerivedAddress8({
       programAddress,
       seeds: [
-        getBytesEncoder15().encode(
+        getBytesEncoder16().encode(
           new Uint8Array([
             115,
             116,
@@ -4208,7 +4265,7 @@ async function getCloseStuckStakeAccountInstructionAsync(input, config) {
     });
   }
   if (!accounts.marketTokenAta.value) {
-    accounts.marketTokenAta.value = await getProgramDerivedAddress7({
+    accounts.marketTokenAta.value = await getProgramDerivedAddress8({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
         getAddressEncoder39().encode(expectAddress(accounts.market.value)),
@@ -4304,29 +4361,183 @@ function parseCloseStuckStakeAccountInstruction(instruction) {
   };
 }
 
-// src/generated/instructions/createMarket.ts
+// src/generated/instructions/closeUnrevealedStakeAccount.ts
 import {
   combineCodec as combineCodec64,
-  fixDecoderSize as fixDecoderSize15,
-  fixEncoderSize as fixEncoderSize16,
-  getAddressDecoder as getAddressDecoder33,
+  fixDecoderSize as fixDecoderSize16,
+  fixEncoderSize as fixEncoderSize17,
   getAddressEncoder as getAddressEncoder40,
-  getArrayDecoder as getArrayDecoder14,
-  getArrayEncoder as getArrayEncoder14,
-  getBooleanDecoder as getBooleanDecoder10,
-  getBooleanEncoder as getBooleanEncoder10,
-  getBytesDecoder as getBytesDecoder15,
-  getBytesEncoder as getBytesEncoder16,
-  getProgramDerivedAddress as getProgramDerivedAddress8,
+  getBytesDecoder as getBytesDecoder16,
+  getBytesEncoder as getBytesEncoder17,
+  getProgramDerivedAddress as getProgramDerivedAddress9,
   getStructDecoder as getStructDecoder58,
   getStructEncoder as getStructEncoder58,
+  transformEncoder as transformEncoder16
+} from "@solana/kit";
+var CLOSE_UNREVEALED_STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
+  171,
+  229,
+  236,
+  216,
+  122,
+  118,
+  188,
+  103
+]);
+function getCloseUnrevealedStakeAccountDiscriminatorBytes() {
+  return fixEncoderSize17(getBytesEncoder17(), 8).encode(
+    CLOSE_UNREVEALED_STAKE_ACCOUNT_DISCRIMINATOR
+  );
+}
+function getCloseUnrevealedStakeAccountInstructionDataEncoder() {
+  return transformEncoder16(
+    getStructEncoder58([["discriminator", fixEncoderSize17(getBytesEncoder17(), 8)]]),
+    (value) => ({
+      ...value,
+      discriminator: CLOSE_UNREVEALED_STAKE_ACCOUNT_DISCRIMINATOR
+    })
+  );
+}
+function getCloseUnrevealedStakeAccountInstructionDataDecoder() {
+  return getStructDecoder58([
+    ["discriminator", fixDecoderSize16(getBytesDecoder16(), 8)]
+  ]);
+}
+function getCloseUnrevealedStakeAccountInstructionDataCodec() {
+  return combineCodec64(
+    getCloseUnrevealedStakeAccountInstructionDataEncoder(),
+    getCloseUnrevealedStakeAccountInstructionDataDecoder()
+  );
+}
+async function getCloseUnrevealedStakeAccountInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    owner: { value: input.owner ?? null, isWritable: true },
+    market: { value: input.market ?? null, isWritable: true },
+    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
+    tokenMint: { value: input.tokenMint ?? null, isWritable: false },
+    marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
+    ownerTokenAccount: {
+      value: input.ownerTokenAccount ?? null,
+      isWritable: true
+    },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.marketTokenAta.value) {
+    accounts.marketTokenAta.value = await getProgramDerivedAddress9({
+      programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+      seeds: [
+        getAddressEncoder40().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder40().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder40().encode(expectAddress(accounts.tokenMint.value))
+      ]
+    });
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.owner),
+      getAccountMeta(accounts.market),
+      getAccountMeta(accounts.stakeAccount),
+      getAccountMeta(accounts.tokenMint),
+      getAccountMeta(accounts.marketTokenAta),
+      getAccountMeta(accounts.ownerTokenAccount),
+      getAccountMeta(accounts.tokenProgram),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    data: getCloseUnrevealedStakeAccountInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function getCloseUnrevealedStakeAccountInstruction(input, config) {
+  const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    owner: { value: input.owner ?? null, isWritable: true },
+    market: { value: input.market ?? null, isWritable: true },
+    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
+    tokenMint: { value: input.tokenMint ?? null, isWritable: false },
+    marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
+    ownerTokenAccount: {
+      value: input.ownerTokenAccount ?? null,
+      isWritable: true
+    },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.owner),
+      getAccountMeta(accounts.market),
+      getAccountMeta(accounts.stakeAccount),
+      getAccountMeta(accounts.tokenMint),
+      getAccountMeta(accounts.marketTokenAta),
+      getAccountMeta(accounts.ownerTokenAccount),
+      getAccountMeta(accounts.tokenProgram),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    data: getCloseUnrevealedStakeAccountInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+function parseCloseUnrevealedStakeAccountInstruction(instruction) {
+  if (instruction.accounts.length < 8) {
+    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: {
+      owner: getNextAccount(),
+      market: getNextAccount(),
+      stakeAccount: getNextAccount(),
+      tokenMint: getNextAccount(),
+      marketTokenAta: getNextAccount(),
+      ownerTokenAccount: getNextAccount(),
+      tokenProgram: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getCloseUnrevealedStakeAccountInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+
+// src/generated/instructions/createMarket.ts
+import {
+  combineCodec as combineCodec65,
+  fixDecoderSize as fixDecoderSize17,
+  fixEncoderSize as fixEncoderSize18,
+  getAddressDecoder as getAddressDecoder32,
+  getAddressEncoder as getAddressEncoder41,
+  getArrayDecoder as getArrayDecoder14,
+  getArrayEncoder as getArrayEncoder14,
+  getBytesDecoder as getBytesDecoder17,
+  getBytesEncoder as getBytesEncoder18,
+  getProgramDerivedAddress as getProgramDerivedAddress10,
+  getStructDecoder as getStructDecoder59,
+  getStructEncoder as getStructEncoder59,
   getU16Decoder as getU16Decoder7,
   getU16Encoder as getU16Encoder7,
   getU64Decoder as getU64Decoder33,
   getU64Encoder as getU64Encoder33,
   getU8Decoder as getU8Decoder21,
   getU8Encoder as getU8Encoder21,
-  transformEncoder as transformEncoder15
+  transformEncoder as transformEncoder17
 } from "@solana/kit";
 var CREATE_MARKET_DISCRIMINATOR = new Uint8Array([
   103,
@@ -4339,43 +4550,39 @@ var CREATE_MARKET_DISCRIMINATOR = new Uint8Array([
   254
 ]);
 function getCreateMarketDiscriminatorBytes() {
-  return fixEncoderSize16(getBytesEncoder16(), 8).encode(
+  return fixEncoderSize18(getBytesEncoder18(), 8).encode(
     CREATE_MARKET_DISCRIMINATOR
   );
 }
 function getCreateMarketInstructionDataEncoder() {
-  return transformEncoder15(
-    getStructEncoder58([
-      ["discriminator", fixEncoderSize16(getBytesEncoder16(), 8)],
+  return transformEncoder17(
+    getStructEncoder59([
+      ["discriminator", fixEncoderSize18(getBytesEncoder18(), 8)],
       ["marketIndex", getU64Encoder33()],
-      ["marketAuthority", getAddressEncoder40()],
-      ["allowUnstakingEarly", getBooleanEncoder10()],
+      ["marketAuthority", getAddressEncoder41()],
       ["authorizedReaderPubkey", getArrayEncoder14(getU8Encoder21(), { size: 32 })],
-      ["revealPeriodAuthority", getAddressEncoder40()],
       ["earlinessCutoffSeconds", getU64Encoder33()],
       ["earlinessMultiplier", getU16Encoder7()],
       ["minStakeAmount", getU64Encoder33()],
-      ["creatorFeeClaimer", getAddressEncoder40()]
+      ["creatorFeeClaimer", getAddressEncoder41()]
     ]),
     (value) => ({ ...value, discriminator: CREATE_MARKET_DISCRIMINATOR })
   );
 }
 function getCreateMarketInstructionDataDecoder() {
-  return getStructDecoder58([
-    ["discriminator", fixDecoderSize15(getBytesDecoder15(), 8)],
+  return getStructDecoder59([
+    ["discriminator", fixDecoderSize17(getBytesDecoder17(), 8)],
     ["marketIndex", getU64Decoder33()],
-    ["marketAuthority", getAddressDecoder33()],
-    ["allowUnstakingEarly", getBooleanDecoder10()],
+    ["marketAuthority", getAddressDecoder32()],
     ["authorizedReaderPubkey", getArrayDecoder14(getU8Decoder21(), { size: 32 })],
-    ["revealPeriodAuthority", getAddressDecoder33()],
     ["earlinessCutoffSeconds", getU64Decoder33()],
     ["earlinessMultiplier", getU16Decoder7()],
     ["minStakeAmount", getU64Decoder33()],
-    ["creatorFeeClaimer", getAddressDecoder33()]
+    ["creatorFeeClaimer", getAddressDecoder32()]
   ]);
 }
 function getCreateMarketInstructionDataCodec() {
-  return combineCodec64(
+  return combineCodec65(
     getCreateMarketInstructionDataEncoder(),
     getCreateMarketInstructionDataDecoder()
   );
@@ -4399,10 +4606,10 @@ async function getCreateMarketInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.market.value) {
-    accounts.market.value = await getProgramDerivedAddress8({
+    accounts.market.value = await getProgramDerivedAddress10({
       programAddress,
       seeds: [
-        getBytesEncoder16().encode(
+        getBytesEncoder18().encode(
           new Uint8Array([
             111,
             112,
@@ -4424,29 +4631,29 @@ async function getCreateMarketInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder40().encode(
+        getAddressEncoder41().encode(
           expectAddress(accounts.platformConfig.value)
         ),
-        getAddressEncoder40().encode(expectAddress(accounts.creator.value)),
+        getAddressEncoder41().encode(expectAddress(accounts.creator.value)),
         getU64Encoder33().encode(expectSome(args.marketIndex))
       ]
     });
   }
   if (!accounts.marketTokenAta.value) {
-    accounts.marketTokenAta.value = await getProgramDerivedAddress8({
+    accounts.marketTokenAta.value = await getProgramDerivedAddress10({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder40().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder40().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder40().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder41().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder41().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder41().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
   if (!accounts.allowedMint.value) {
-    accounts.allowedMint.value = await getProgramDerivedAddress8({
+    accounts.allowedMint.value = await getProgramDerivedAddress10({
       programAddress,
       seeds: [
-        getBytesEncoder16().encode(
+        getBytesEncoder18().encode(
           new Uint8Array([
             97,
             108,
@@ -4462,10 +4669,10 @@ async function getCreateMarketInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder40().encode(
+        getAddressEncoder41().encode(
           expectAddress(accounts.platformConfig.value)
         ),
-        getAddressEncoder40().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder41().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -4566,14 +4773,14 @@ function parseCreateMarketInstruction(instruction) {
 
 // src/generated/instructions/endRevealPeriod.ts
 import {
-  combineCodec as combineCodec65,
-  fixDecoderSize as fixDecoderSize16,
-  fixEncoderSize as fixEncoderSize17,
-  getBytesDecoder as getBytesDecoder16,
-  getBytesEncoder as getBytesEncoder17,
-  getStructDecoder as getStructDecoder59,
-  getStructEncoder as getStructEncoder59,
-  transformEncoder as transformEncoder16
+  combineCodec as combineCodec66,
+  fixDecoderSize as fixDecoderSize18,
+  fixEncoderSize as fixEncoderSize19,
+  getBytesDecoder as getBytesDecoder18,
+  getBytesEncoder as getBytesEncoder19,
+  getStructDecoder as getStructDecoder60,
+  getStructEncoder as getStructEncoder60,
+  transformEncoder as transformEncoder18
 } from "@solana/kit";
 var END_REVEAL_PERIOD_DISCRIMINATOR = new Uint8Array([
   144,
@@ -4586,23 +4793,23 @@ var END_REVEAL_PERIOD_DISCRIMINATOR = new Uint8Array([
   92
 ]);
 function getEndRevealPeriodDiscriminatorBytes() {
-  return fixEncoderSize17(getBytesEncoder17(), 8).encode(
+  return fixEncoderSize19(getBytesEncoder19(), 8).encode(
     END_REVEAL_PERIOD_DISCRIMINATOR
   );
 }
 function getEndRevealPeriodInstructionDataEncoder() {
-  return transformEncoder16(
-    getStructEncoder59([["discriminator", fixEncoderSize17(getBytesEncoder17(), 8)]]),
+  return transformEncoder18(
+    getStructEncoder60([["discriminator", fixEncoderSize19(getBytesEncoder19(), 8)]]),
     (value) => ({ ...value, discriminator: END_REVEAL_PERIOD_DISCRIMINATOR })
   );
 }
 function getEndRevealPeriodInstructionDataDecoder() {
-  return getStructDecoder59([
-    ["discriminator", fixDecoderSize16(getBytesDecoder16(), 8)]
+  return getStructDecoder60([
+    ["discriminator", fixDecoderSize18(getBytesDecoder18(), 8)]
   ]);
 }
 function getEndRevealPeriodInstructionDataCodec() {
-  return combineCodec65(
+  return combineCodec66(
     getEndRevealPeriodInstructionDataEncoder(),
     getEndRevealPeriodInstructionDataDecoder()
   );
@@ -4611,21 +4818,23 @@ function getEndRevealPeriodInstruction(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
     signer: { value: input.signer ?? null, isWritable: false },
-    market: { value: input.market ?? null, isWritable: true }
+    market: { value: input.market ?? null, isWritable: true },
+    platformConfig: { value: input.platformConfig ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
   const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta(accounts.signer),
-      getAccountMeta(accounts.market)
+      getAccountMeta(accounts.market),
+      getAccountMeta(accounts.platformConfig)
     ],
     data: getEndRevealPeriodInstructionDataEncoder().encode({}),
     programAddress
   });
 }
 function parseEndRevealPeriodInstruction(instruction) {
-  if (instruction.accounts.length < 2) {
+  if (instruction.accounts.length < 3) {
     throw new Error("Not enough accounts");
   }
   let accountIndex = 0;
@@ -4636,27 +4845,31 @@ function parseEndRevealPeriodInstruction(instruction) {
   };
   return {
     programAddress: instruction.programAddress,
-    accounts: { signer: getNextAccount(), market: getNextAccount() },
+    accounts: {
+      signer: getNextAccount(),
+      market: getNextAccount(),
+      platformConfig: getNextAccount()
+    },
     data: getEndRevealPeriodInstructionDataDecoder().decode(instruction.data)
   };
 }
 
 // src/generated/instructions/finalizeRevealStake.ts
 import {
-  combineCodec as combineCodec66,
-  fixDecoderSize as fixDecoderSize17,
-  fixEncoderSize as fixEncoderSize18,
-  getAddressEncoder as getAddressEncoder41,
-  getBytesDecoder as getBytesDecoder17,
-  getBytesEncoder as getBytesEncoder18,
-  getProgramDerivedAddress as getProgramDerivedAddress9,
-  getStructDecoder as getStructDecoder60,
-  getStructEncoder as getStructEncoder60,
+  combineCodec as combineCodec67,
+  fixDecoderSize as fixDecoderSize19,
+  fixEncoderSize as fixEncoderSize20,
+  getAddressEncoder as getAddressEncoder42,
+  getBytesDecoder as getBytesDecoder19,
+  getBytesEncoder as getBytesEncoder20,
+  getProgramDerivedAddress as getProgramDerivedAddress11,
+  getStructDecoder as getStructDecoder61,
+  getStructEncoder as getStructEncoder61,
   getU32Decoder as getU32Decoder17,
   getU32Encoder as getU32Encoder17,
   getU64Decoder as getU64Decoder34,
   getU64Encoder as getU64Encoder34,
-  transformEncoder as transformEncoder17
+  transformEncoder as transformEncoder19
 } from "@solana/kit";
 var FINALIZE_REVEAL_STAKE_DISCRIMINATOR = new Uint8Array([
   92,
@@ -4669,14 +4882,14 @@ var FINALIZE_REVEAL_STAKE_DISCRIMINATOR = new Uint8Array([
   230
 ]);
 function getFinalizeRevealStakeDiscriminatorBytes() {
-  return fixEncoderSize18(getBytesEncoder18(), 8).encode(
+  return fixEncoderSize20(getBytesEncoder20(), 8).encode(
     FINALIZE_REVEAL_STAKE_DISCRIMINATOR
   );
 }
 function getFinalizeRevealStakeInstructionDataEncoder() {
-  return transformEncoder17(
-    getStructEncoder60([
-      ["discriminator", fixEncoderSize18(getBytesEncoder18(), 8)],
+  return transformEncoder19(
+    getStructEncoder61([
+      ["discriminator", fixEncoderSize20(getBytesEncoder20(), 8)],
       ["optionId", getU64Encoder34()],
       ["stakeAccountId", getU32Encoder17()]
     ]),
@@ -4687,14 +4900,14 @@ function getFinalizeRevealStakeInstructionDataEncoder() {
   );
 }
 function getFinalizeRevealStakeInstructionDataDecoder() {
-  return getStructDecoder60([
-    ["discriminator", fixDecoderSize17(getBytesDecoder17(), 8)],
+  return getStructDecoder61([
+    ["discriminator", fixDecoderSize19(getBytesDecoder19(), 8)],
     ["optionId", getU64Decoder34()],
     ["stakeAccountId", getU32Decoder17()]
   ]);
 }
 function getFinalizeRevealStakeInstructionDataCodec() {
-  return combineCodec66(
+  return combineCodec67(
     getFinalizeRevealStakeInstructionDataEncoder(),
     getFinalizeRevealStakeInstructionDataDecoder()
   );
@@ -4712,10 +4925,10 @@ async function getFinalizeRevealStakeInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.stakeAccount.value) {
-    accounts.stakeAccount.value = await getProgramDerivedAddress9({
+    accounts.stakeAccount.value = await getProgramDerivedAddress11({
       programAddress,
       seeds: [
-        getBytesEncoder18().encode(
+        getBytesEncoder20().encode(
           new Uint8Array([
             115,
             116,
@@ -4732,20 +4945,20 @@ async function getFinalizeRevealStakeInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder41().encode(expectAddress(accounts.owner.value)),
-        getAddressEncoder41().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder42().encode(expectAddress(accounts.owner.value)),
+        getAddressEncoder42().encode(expectAddress(accounts.market.value)),
         getU32Encoder17().encode(expectSome(args.stakeAccountId))
       ]
     });
   }
   if (!accounts.option.value) {
-    accounts.option.value = await getProgramDerivedAddress9({
+    accounts.option.value = await getProgramDerivedAddress11({
       programAddress,
       seeds: [
-        getBytesEncoder18().encode(
+        getBytesEncoder20().encode(
           new Uint8Array([111, 112, 116, 105, 111, 110])
         ),
-        getAddressEncoder41().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder42().encode(expectAddress(accounts.market.value)),
         getU64Encoder34().encode(expectSome(args.optionId))
       ]
     });
@@ -4828,16 +5041,16 @@ function parseFinalizeRevealStakeInstruction(instruction) {
 
 // src/generated/instructions/initAllowedMint.ts
 import {
-  combineCodec as combineCodec67,
-  fixDecoderSize as fixDecoderSize18,
-  fixEncoderSize as fixEncoderSize19,
-  getAddressEncoder as getAddressEncoder42,
-  getBytesDecoder as getBytesDecoder18,
-  getBytesEncoder as getBytesEncoder19,
-  getProgramDerivedAddress as getProgramDerivedAddress10,
-  getStructDecoder as getStructDecoder61,
-  getStructEncoder as getStructEncoder61,
-  transformEncoder as transformEncoder18
+  combineCodec as combineCodec68,
+  fixDecoderSize as fixDecoderSize20,
+  fixEncoderSize as fixEncoderSize21,
+  getAddressEncoder as getAddressEncoder43,
+  getBytesDecoder as getBytesDecoder20,
+  getBytesEncoder as getBytesEncoder21,
+  getProgramDerivedAddress as getProgramDerivedAddress12,
+  getStructDecoder as getStructDecoder62,
+  getStructEncoder as getStructEncoder62,
+  transformEncoder as transformEncoder20
 } from "@solana/kit";
 var INIT_ALLOWED_MINT_DISCRIMINATOR = new Uint8Array([
   215,
@@ -4850,23 +5063,23 @@ var INIT_ALLOWED_MINT_DISCRIMINATOR = new Uint8Array([
   10
 ]);
 function getInitAllowedMintDiscriminatorBytes() {
-  return fixEncoderSize19(getBytesEncoder19(), 8).encode(
+  return fixEncoderSize21(getBytesEncoder21(), 8).encode(
     INIT_ALLOWED_MINT_DISCRIMINATOR
   );
 }
 function getInitAllowedMintInstructionDataEncoder() {
-  return transformEncoder18(
-    getStructEncoder61([["discriminator", fixEncoderSize19(getBytesEncoder19(), 8)]]),
+  return transformEncoder20(
+    getStructEncoder62([["discriminator", fixEncoderSize21(getBytesEncoder21(), 8)]]),
     (value) => ({ ...value, discriminator: INIT_ALLOWED_MINT_DISCRIMINATOR })
   );
 }
 function getInitAllowedMintInstructionDataDecoder() {
-  return getStructDecoder61([
-    ["discriminator", fixDecoderSize18(getBytesDecoder18(), 8)]
+  return getStructDecoder62([
+    ["discriminator", fixDecoderSize20(getBytesDecoder20(), 8)]
   ]);
 }
 function getInitAllowedMintInstructionDataCodec() {
-  return combineCodec67(
+  return combineCodec68(
     getInitAllowedMintInstructionDataEncoder(),
     getInitAllowedMintInstructionDataDecoder()
   );
@@ -4882,10 +5095,10 @@ async function getInitAllowedMintInstructionAsync(input, config) {
   };
   const accounts = originalAccounts;
   if (!accounts.allowedMint.value) {
-    accounts.allowedMint.value = await getProgramDerivedAddress10({
+    accounts.allowedMint.value = await getProgramDerivedAddress12({
       programAddress,
       seeds: [
-        getBytesEncoder19().encode(
+        getBytesEncoder21().encode(
           new Uint8Array([
             97,
             108,
@@ -4901,10 +5114,10 @@ async function getInitAllowedMintInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder42().encode(
+        getAddressEncoder43().encode(
           expectAddress(accounts.platformConfig.value)
         ),
-        getAddressEncoder42().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder43().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -4977,16 +5190,16 @@ function parseInitAllowedMintInstruction(instruction) {
 import {
   addDecoderSizePrefix as addDecoderSizePrefix3,
   addEncoderSizePrefix as addEncoderSizePrefix3,
-  combineCodec as combineCodec68,
-  fixDecoderSize as fixDecoderSize19,
-  fixEncoderSize as fixEncoderSize20,
-  getAddressDecoder as getAddressDecoder34,
-  getAddressEncoder as getAddressEncoder43,
-  getBytesDecoder as getBytesDecoder19,
-  getBytesEncoder as getBytesEncoder20,
-  getProgramDerivedAddress as getProgramDerivedAddress11,
-  getStructDecoder as getStructDecoder62,
-  getStructEncoder as getStructEncoder62,
+  combineCodec as combineCodec69,
+  fixDecoderSize as fixDecoderSize21,
+  fixEncoderSize as fixEncoderSize22,
+  getAddressDecoder as getAddressDecoder33,
+  getAddressEncoder as getAddressEncoder44,
+  getBytesDecoder as getBytesDecoder21,
+  getBytesEncoder as getBytesEncoder22,
+  getProgramDerivedAddress as getProgramDerivedAddress13,
+  getStructDecoder as getStructDecoder63,
+  getStructEncoder as getStructEncoder63,
   getU16Decoder as getU16Decoder8,
   getU16Encoder as getU16Encoder8,
   getU32Decoder as getU32Decoder18,
@@ -4995,7 +5208,7 @@ import {
   getU64Encoder as getU64Encoder35,
   getUtf8Decoder as getUtf8Decoder3,
   getUtf8Encoder as getUtf8Encoder3,
-  transformEncoder as transformEncoder19
+  transformEncoder as transformEncoder21
 } from "@solana/kit";
 var INIT_PLATFORM_CONFIG_DISCRIMINATOR = new Uint8Array([
   101,
@@ -5008,43 +5221,43 @@ var INIT_PLATFORM_CONFIG_DISCRIMINATOR = new Uint8Array([
   118
 ]);
 function getInitPlatformConfigDiscriminatorBytes() {
-  return fixEncoderSize20(getBytesEncoder20(), 8).encode(
+  return fixEncoderSize22(getBytesEncoder22(), 8).encode(
     INIT_PLATFORM_CONFIG_DISCRIMINATOR
   );
 }
 function getInitPlatformConfigInstructionDataEncoder() {
-  return transformEncoder19(
-    getStructEncoder62([
-      ["discriminator", fixEncoderSize20(getBytesEncoder20(), 8)],
+  return transformEncoder21(
+    getStructEncoder63([
+      ["discriminator", fixEncoderSize22(getBytesEncoder22(), 8)],
       ["name", addEncoderSizePrefix3(getUtf8Encoder3(), getU32Encoder18())],
       ["platformFeeBp", getU16Encoder8()],
       ["rewardPoolFeeBp", getU16Encoder8()],
       ["creatorFeeBp", getU16Encoder8()],
-      ["feeClaimAuthority", getAddressEncoder43()],
+      ["feeClaimAuthority", getAddressEncoder44()],
+      ["revealAuthority", getAddressEncoder44()],
       ["minTimeToStakeSeconds", getU64Encoder35()],
-      ["minRevealPeriodSeconds", getU64Encoder35()],
-      ["maxRevealPeriodSeconds", getU64Encoder35()],
+      ["revealPeriodSeconds", getU64Encoder35()],
       ["marketResolutionDeadlineSeconds", getU64Encoder35()]
     ]),
     (value) => ({ ...value, discriminator: INIT_PLATFORM_CONFIG_DISCRIMINATOR })
   );
 }
 function getInitPlatformConfigInstructionDataDecoder() {
-  return getStructDecoder62([
-    ["discriminator", fixDecoderSize19(getBytesDecoder19(), 8)],
+  return getStructDecoder63([
+    ["discriminator", fixDecoderSize21(getBytesDecoder21(), 8)],
     ["name", addDecoderSizePrefix3(getUtf8Decoder3(), getU32Decoder18())],
     ["platformFeeBp", getU16Decoder8()],
     ["rewardPoolFeeBp", getU16Decoder8()],
     ["creatorFeeBp", getU16Decoder8()],
-    ["feeClaimAuthority", getAddressDecoder34()],
+    ["feeClaimAuthority", getAddressDecoder33()],
+    ["revealAuthority", getAddressDecoder33()],
     ["minTimeToStakeSeconds", getU64Decoder35()],
-    ["minRevealPeriodSeconds", getU64Decoder35()],
-    ["maxRevealPeriodSeconds", getU64Decoder35()],
+    ["revealPeriodSeconds", getU64Decoder35()],
     ["marketResolutionDeadlineSeconds", getU64Decoder35()]
   ]);
 }
 function getInitPlatformConfigInstructionDataCodec() {
-  return combineCodec68(
+  return combineCodec69(
     getInitPlatformConfigInstructionDataEncoder(),
     getInitPlatformConfigInstructionDataDecoder()
   );
@@ -5059,10 +5272,10 @@ async function getInitPlatformConfigInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.platformConfig.value) {
-    accounts.platformConfig.value = await getProgramDerivedAddress11({
+    accounts.platformConfig.value = await getProgramDerivedAddress13({
       programAddress,
       seeds: [
-        getBytesEncoder20().encode(
+        getBytesEncoder22().encode(
           new Uint8Array([
             112,
             108,
@@ -5081,7 +5294,7 @@ async function getInitPlatformConfigInstructionAsync(input, config) {
             103
           ])
         ),
-        getAddressEncoder43().encode(expectAddress(accounts.payer.value)),
+        getAddressEncoder44().encode(expectAddress(accounts.payer.value)),
         getUtf8Encoder3().encode(expectSome(args.name))
       ]
     });
@@ -5152,18 +5365,18 @@ function parseInitPlatformConfigInstruction(instruction) {
 
 // src/generated/instructions/initStakeAccount.ts
 import {
-  combineCodec as combineCodec69,
-  fixDecoderSize as fixDecoderSize20,
-  fixEncoderSize as fixEncoderSize21,
-  getAddressEncoder as getAddressEncoder44,
-  getBytesDecoder as getBytesDecoder20,
-  getBytesEncoder as getBytesEncoder21,
-  getProgramDerivedAddress as getProgramDerivedAddress12,
-  getStructDecoder as getStructDecoder63,
-  getStructEncoder as getStructEncoder63,
+  combineCodec as combineCodec70,
+  fixDecoderSize as fixDecoderSize22,
+  fixEncoderSize as fixEncoderSize23,
+  getAddressEncoder as getAddressEncoder45,
+  getBytesDecoder as getBytesDecoder22,
+  getBytesEncoder as getBytesEncoder23,
+  getProgramDerivedAddress as getProgramDerivedAddress14,
+  getStructDecoder as getStructDecoder64,
+  getStructEncoder as getStructEncoder64,
   getU32Decoder as getU32Decoder19,
   getU32Encoder as getU32Encoder19,
-  transformEncoder as transformEncoder20
+  transformEncoder as transformEncoder22
 } from "@solana/kit";
 var INIT_STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   132,
@@ -5176,27 +5389,27 @@ var INIT_STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   45
 ]);
 function getInitStakeAccountDiscriminatorBytes() {
-  return fixEncoderSize21(getBytesEncoder21(), 8).encode(
+  return fixEncoderSize23(getBytesEncoder23(), 8).encode(
     INIT_STAKE_ACCOUNT_DISCRIMINATOR
   );
 }
 function getInitStakeAccountInstructionDataEncoder() {
-  return transformEncoder20(
-    getStructEncoder63([
-      ["discriminator", fixEncoderSize21(getBytesEncoder21(), 8)],
+  return transformEncoder22(
+    getStructEncoder64([
+      ["discriminator", fixEncoderSize23(getBytesEncoder23(), 8)],
       ["stakeAccountId", getU32Encoder19()]
     ]),
     (value) => ({ ...value, discriminator: INIT_STAKE_ACCOUNT_DISCRIMINATOR })
   );
 }
 function getInitStakeAccountInstructionDataDecoder() {
-  return getStructDecoder63([
-    ["discriminator", fixDecoderSize20(getBytesDecoder20(), 8)],
+  return getStructDecoder64([
+    ["discriminator", fixDecoderSize22(getBytesDecoder22(), 8)],
     ["stakeAccountId", getU32Decoder19()]
   ]);
 }
 function getInitStakeAccountInstructionDataCodec() {
-  return combineCodec69(
+  return combineCodec70(
     getInitStakeAccountInstructionDataEncoder(),
     getInitStakeAccountInstructionDataDecoder()
   );
@@ -5213,10 +5426,10 @@ async function getInitStakeAccountInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.stakeAccount.value) {
-    accounts.stakeAccount.value = await getProgramDerivedAddress12({
+    accounts.stakeAccount.value = await getProgramDerivedAddress14({
       programAddress,
       seeds: [
-        getBytesEncoder21().encode(
+        getBytesEncoder23().encode(
           new Uint8Array([
             115,
             116,
@@ -5233,8 +5446,8 @@ async function getInitStakeAccountInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder44().encode(expectAddress(accounts.owner.value)),
-        getAddressEncoder44().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder45().encode(expectAddress(accounts.owner.value)),
+        getAddressEncoder45().encode(expectAddress(accounts.market.value)),
         getU32Encoder19().encode(expectSome(args.stakeAccountId))
       ]
     });
@@ -5311,16 +5524,16 @@ function parseInitStakeAccountInstruction(instruction) {
 
 // src/generated/instructions/openMarket.ts
 import {
-  combineCodec as combineCodec70,
-  fixDecoderSize as fixDecoderSize21,
-  fixEncoderSize as fixEncoderSize22,
-  getBytesDecoder as getBytesDecoder21,
-  getBytesEncoder as getBytesEncoder22,
-  getStructDecoder as getStructDecoder64,
-  getStructEncoder as getStructEncoder64,
+  combineCodec as combineCodec71,
+  fixDecoderSize as fixDecoderSize23,
+  fixEncoderSize as fixEncoderSize24,
+  getBytesDecoder as getBytesDecoder23,
+  getBytesEncoder as getBytesEncoder24,
+  getStructDecoder as getStructDecoder65,
+  getStructEncoder as getStructEncoder65,
   getU64Decoder as getU64Decoder36,
   getU64Encoder as getU64Encoder36,
-  transformEncoder as transformEncoder21
+  transformEncoder as transformEncoder23
 } from "@solana/kit";
 var OPEN_MARKET_DISCRIMINATOR = new Uint8Array([
   116,
@@ -5333,25 +5546,25 @@ var OPEN_MARKET_DISCRIMINATOR = new Uint8Array([
   44
 ]);
 function getOpenMarketDiscriminatorBytes() {
-  return fixEncoderSize22(getBytesEncoder22(), 8).encode(OPEN_MARKET_DISCRIMINATOR);
+  return fixEncoderSize24(getBytesEncoder24(), 8).encode(OPEN_MARKET_DISCRIMINATOR);
 }
 function getOpenMarketInstructionDataEncoder() {
-  return transformEncoder21(
-    getStructEncoder64([
-      ["discriminator", fixEncoderSize22(getBytesEncoder22(), 8)],
+  return transformEncoder23(
+    getStructEncoder65([
+      ["discriminator", fixEncoderSize24(getBytesEncoder24(), 8)],
       ["timeToStake", getU64Encoder36()]
     ]),
     (value) => ({ ...value, discriminator: OPEN_MARKET_DISCRIMINATOR })
   );
 }
 function getOpenMarketInstructionDataDecoder() {
-  return getStructDecoder64([
-    ["discriminator", fixDecoderSize21(getBytesDecoder21(), 8)],
+  return getStructDecoder65([
+    ["discriminator", fixDecoderSize23(getBytesDecoder23(), 8)],
     ["timeToStake", getU64Decoder36()]
   ]);
 }
 function getOpenMarketInstructionDataCodec() {
-  return combineCodec70(
+  return combineCodec71(
     getOpenMarketInstructionDataEncoder(),
     getOpenMarketInstructionDataDecoder()
   );
@@ -5402,96 +5615,16 @@ function parseOpenMarketInstruction(instruction) {
   };
 }
 
-// src/generated/instructions/pauseStaking.ts
-import {
-  combineCodec as combineCodec71,
-  fixDecoderSize as fixDecoderSize22,
-  fixEncoderSize as fixEncoderSize23,
-  getBytesDecoder as getBytesDecoder22,
-  getBytesEncoder as getBytesEncoder23,
-  getStructDecoder as getStructDecoder65,
-  getStructEncoder as getStructEncoder65,
-  transformEncoder as transformEncoder22
-} from "@solana/kit";
-var PAUSE_STAKING_DISCRIMINATOR = new Uint8Array([
-  245,
-  191,
-  35,
-  58,
-  88,
-  250,
-  229,
-  60
-]);
-function getPauseStakingDiscriminatorBytes() {
-  return fixEncoderSize23(getBytesEncoder23(), 8).encode(
-    PAUSE_STAKING_DISCRIMINATOR
-  );
-}
-function getPauseStakingInstructionDataEncoder() {
-  return transformEncoder22(
-    getStructEncoder65([["discriminator", fixEncoderSize23(getBytesEncoder23(), 8)]]),
-    (value) => ({ ...value, discriminator: PAUSE_STAKING_DISCRIMINATOR })
-  );
-}
-function getPauseStakingInstructionDataDecoder() {
-  return getStructDecoder65([
-    ["discriminator", fixDecoderSize22(getBytesDecoder22(), 8)]
-  ]);
-}
-function getPauseStakingInstructionDataCodec() {
-  return combineCodec71(
-    getPauseStakingInstructionDataEncoder(),
-    getPauseStakingInstructionDataDecoder()
-  );
-}
-function getPauseStakingInstruction(input, config) {
-  const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    marketAuthority: {
-      value: input.marketAuthority ?? null,
-      isWritable: false
-    },
-    market: { value: input.market ?? null, isWritable: true }
-  };
-  const accounts = originalAccounts;
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.marketAuthority),
-      getAccountMeta(accounts.market)
-    ],
-    data: getPauseStakingInstructionDataEncoder().encode({}),
-    programAddress
-  });
-}
-function parsePauseStakingInstruction(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: { marketAuthority: getNextAccount(), market: getNextAccount() },
-    data: getPauseStakingInstructionDataDecoder().decode(instruction.data)
-  };
-}
-
 // src/generated/instructions/resolveMarket.ts
 import {
   combineCodec as combineCodec72,
-  fixDecoderSize as fixDecoderSize23,
-  fixEncoderSize as fixEncoderSize24,
-  getBytesDecoder as getBytesDecoder23,
-  getBytesEncoder as getBytesEncoder24,
+  fixDecoderSize as fixDecoderSize24,
+  fixEncoderSize as fixEncoderSize25,
+  getBytesDecoder as getBytesDecoder24,
+  getBytesEncoder as getBytesEncoder25,
   getStructDecoder as getStructDecoder66,
   getStructEncoder as getStructEncoder66,
-  transformEncoder as transformEncoder23
+  transformEncoder as transformEncoder24
 } from "@solana/kit";
 var RESOLVE_MARKET_DISCRIMINATOR = new Uint8Array([
   155,
@@ -5504,108 +5637,28 @@ var RESOLVE_MARKET_DISCRIMINATOR = new Uint8Array([
   239
 ]);
 function getResolveMarketDiscriminatorBytes() {
-  return fixEncoderSize24(getBytesEncoder24(), 8).encode(
+  return fixEncoderSize25(getBytesEncoder25(), 8).encode(
     RESOLVE_MARKET_DISCRIMINATOR
   );
 }
 function getResolveMarketInstructionDataEncoder() {
-  return transformEncoder23(
-    getStructEncoder66([["discriminator", fixEncoderSize24(getBytesEncoder24(), 8)]]),
+  return transformEncoder24(
+    getStructEncoder66([["discriminator", fixEncoderSize25(getBytesEncoder25(), 8)]]),
     (value) => ({ ...value, discriminator: RESOLVE_MARKET_DISCRIMINATOR })
   );
 }
 function getResolveMarketInstructionDataDecoder() {
-  return getStructDecoder66([
-    ["discriminator", fixDecoderSize23(getBytesDecoder23(), 8)]
-  ]);
-}
-function getResolveMarketInstructionDataCodec() {
-  return combineCodec72(
-    getResolveMarketInstructionDataEncoder(),
-    getResolveMarketInstructionDataDecoder()
-  );
-}
-function getResolveMarketInstruction(input, config) {
-  const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    marketAuthority: {
-      value: input.marketAuthority ?? null,
-      isWritable: false
-    },
-    market: { value: input.market ?? null, isWritable: true }
-  };
-  const accounts = originalAccounts;
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.marketAuthority),
-      getAccountMeta(accounts.market)
-    ],
-    data: getResolveMarketInstructionDataEncoder().encode({}),
-    programAddress
-  });
-}
-function parseResolveMarketInstruction(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: { marketAuthority: getNextAccount(), market: getNextAccount() },
-    data: getResolveMarketInstructionDataDecoder().decode(instruction.data)
-  };
-}
-
-// src/generated/instructions/resumeStaking.ts
-import {
-  combineCodec as combineCodec73,
-  fixDecoderSize as fixDecoderSize24,
-  fixEncoderSize as fixEncoderSize25,
-  getBytesDecoder as getBytesDecoder24,
-  getBytesEncoder as getBytesEncoder25,
-  getStructDecoder as getStructDecoder67,
-  getStructEncoder as getStructEncoder67,
-  transformEncoder as transformEncoder24
-} from "@solana/kit";
-var RESUME_STAKING_DISCRIMINATOR = new Uint8Array([
-  31,
-  200,
-  175,
-  23,
-  211,
-  22,
-  63,
-  155
-]);
-function getResumeStakingDiscriminatorBytes() {
-  return fixEncoderSize25(getBytesEncoder25(), 8).encode(
-    RESUME_STAKING_DISCRIMINATOR
-  );
-}
-function getResumeStakingInstructionDataEncoder() {
-  return transformEncoder24(
-    getStructEncoder67([["discriminator", fixEncoderSize25(getBytesEncoder25(), 8)]]),
-    (value) => ({ ...value, discriminator: RESUME_STAKING_DISCRIMINATOR })
-  );
-}
-function getResumeStakingInstructionDataDecoder() {
-  return getStructDecoder67([
+  return getStructDecoder66([
     ["discriminator", fixDecoderSize24(getBytesDecoder24(), 8)]
   ]);
 }
-function getResumeStakingInstructionDataCodec() {
-  return combineCodec73(
-    getResumeStakingInstructionDataEncoder(),
-    getResumeStakingInstructionDataDecoder()
+function getResolveMarketInstructionDataCodec() {
+  return combineCodec72(
+    getResolveMarketInstructionDataEncoder(),
+    getResolveMarketInstructionDataDecoder()
   );
 }
-function getResumeStakingInstruction(input, config) {
+function getResolveMarketInstruction(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
     marketAuthority: {
@@ -5621,11 +5674,11 @@ function getResumeStakingInstruction(input, config) {
       getAccountMeta(accounts.marketAuthority),
       getAccountMeta(accounts.market)
     ],
-    data: getResumeStakingInstructionDataEncoder().encode({}),
+    data: getResolveMarketInstructionDataEncoder().encode({}),
     programAddress
   });
 }
-function parseResumeStakingInstruction(instruction) {
+function parseResolveMarketInstruction(instruction) {
   if (instruction.accounts.length < 2) {
     throw new Error("Not enough accounts");
   }
@@ -5638,21 +5691,21 @@ function parseResumeStakingInstruction(instruction) {
   return {
     programAddress: instruction.programAddress,
     accounts: { marketAuthority: getNextAccount(), market: getNextAccount() },
-    data: getResumeStakingInstructionDataDecoder().decode(instruction.data)
+    data: getResolveMarketInstructionDataDecoder().decode(instruction.data)
   };
 }
 
 // src/generated/instructions/revealStake.ts
 import {
-  combineCodec as combineCodec74,
+  combineCodec as combineCodec73,
   fixDecoderSize as fixDecoderSize25,
   fixEncoderSize as fixEncoderSize26,
-  getAddressEncoder as getAddressEncoder45,
+  getAddressEncoder as getAddressEncoder46,
   getBytesDecoder as getBytesDecoder25,
   getBytesEncoder as getBytesEncoder26,
-  getProgramDerivedAddress as getProgramDerivedAddress13,
-  getStructDecoder as getStructDecoder68,
-  getStructEncoder as getStructEncoder68,
+  getProgramDerivedAddress as getProgramDerivedAddress15,
+  getStructDecoder as getStructDecoder67,
+  getStructEncoder as getStructEncoder67,
   getU32Decoder as getU32Decoder20,
   getU32Encoder as getU32Encoder20,
   getU64Decoder as getU64Decoder37,
@@ -5676,7 +5729,7 @@ function getRevealStakeDiscriminatorBytes() {
 }
 function getRevealStakeInstructionDataEncoder() {
   return transformEncoder25(
-    getStructEncoder68([
+    getStructEncoder67([
       ["discriminator", fixEncoderSize26(getBytesEncoder26(), 8)],
       ["computationOffset", getU64Encoder37()],
       ["stakeAccountId", getU32Encoder20()]
@@ -5685,14 +5738,14 @@ function getRevealStakeInstructionDataEncoder() {
   );
 }
 function getRevealStakeInstructionDataDecoder() {
-  return getStructDecoder68([
+  return getStructDecoder67([
     ["discriminator", fixDecoderSize25(getBytesDecoder25(), 8)],
     ["computationOffset", getU64Decoder37()],
     ["stakeAccountId", getU32Decoder20()]
   ]);
 }
 function getRevealStakeInstructionDataCodec() {
-  return combineCodec74(
+  return combineCodec73(
     getRevealStakeInstructionDataEncoder(),
     getRevealStakeInstructionDataDecoder()
   );
@@ -5722,7 +5775,7 @@ async function getRevealStakeInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.stakeAccount.value) {
-    accounts.stakeAccount.value = await getProgramDerivedAddress13({
+    accounts.stakeAccount.value = await getProgramDerivedAddress15({
       programAddress,
       seeds: [
         getBytesEncoder26().encode(
@@ -5742,14 +5795,14 @@ async function getRevealStakeInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder45().encode(expectAddress(accounts.owner.value)),
-        getAddressEncoder45().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder46().encode(expectAddress(accounts.owner.value)),
+        getAddressEncoder46().encode(expectAddress(accounts.market.value)),
         getU32Encoder20().encode(expectSome(args.stakeAccountId))
       ]
     });
   }
   if (!accounts.signPdaAccount.value) {
-    accounts.signPdaAccount.value = await getProgramDerivedAddress13({
+    accounts.signPdaAccount.value = await getProgramDerivedAddress15({
       programAddress,
       seeds: [
         getBytesEncoder26().encode(
@@ -5911,7 +5964,7 @@ function parseRevealStakeInstruction(instruction) {
 
 // src/generated/instructions/revealStakeCallback.ts
 import {
-  combineCodec as combineCodec75,
+  combineCodec as combineCodec74,
   fixDecoderSize as fixDecoderSize26,
   fixEncoderSize as fixEncoderSize27,
   getArrayDecoder as getArrayDecoder15,
@@ -5920,8 +5973,8 @@ import {
   getBytesEncoder as getBytesEncoder27,
   getDiscriminatedUnionDecoder as getDiscriminatedUnionDecoder4,
   getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder4,
-  getStructDecoder as getStructDecoder69,
-  getStructEncoder as getStructEncoder69,
+  getStructDecoder as getStructDecoder68,
+  getStructEncoder as getStructEncoder68,
   getTupleDecoder as getTupleDecoder6,
   getTupleEncoder as getTupleEncoder6,
   getU8Decoder as getU8Decoder22,
@@ -5947,14 +6000,14 @@ function getRevealStakeCallbackDiscriminatorBytes() {
 }
 function getRevealStakeCallbackInstructionDataEncoder() {
   return transformEncoder26(
-    getStructEncoder69([
+    getStructEncoder68([
       ["discriminator", fixEncoderSize27(getBytesEncoder27(), 8)],
       [
         "output",
         getDiscriminatedUnionEncoder4([
           [
             "Success",
-            getStructEncoder69([
+            getStructEncoder68([
               [
                 "fields",
                 getTupleEncoder6([
@@ -5967,7 +6020,7 @@ function getRevealStakeCallbackInstructionDataEncoder() {
           ["Failure", getUnitEncoder()],
           [
             "MarkerForIdlBuildDoNotUseThis",
-            getStructEncoder69([
+            getStructEncoder68([
               ["fields", getTupleEncoder6([getRevealStakeOutputEncoder()])]
             ])
           ]
@@ -5981,14 +6034,14 @@ function getRevealStakeCallbackInstructionDataEncoder() {
   );
 }
 function getRevealStakeCallbackInstructionDataDecoder() {
-  return getStructDecoder69([
+  return getStructDecoder68([
     ["discriminator", fixDecoderSize26(getBytesDecoder26(), 8)],
     [
       "output",
       getDiscriminatedUnionDecoder4([
         [
           "Success",
-          getStructDecoder69([
+          getStructDecoder68([
             [
               "fields",
               getTupleDecoder6([
@@ -6001,7 +6054,7 @@ function getRevealStakeCallbackInstructionDataDecoder() {
         ["Failure", getUnitDecoder()],
         [
           "MarkerForIdlBuildDoNotUseThis",
-          getStructDecoder69([
+          getStructDecoder68([
             ["fields", getTupleDecoder6([getRevealStakeOutputDecoder()])]
           ])
         ]
@@ -6010,7 +6063,7 @@ function getRevealStakeCallbackInstructionDataDecoder() {
   ]);
 }
 function getRevealStakeCallbackInstructionDataCodec() {
-  return combineCodec75(
+  return combineCodec74(
     getRevealStakeCallbackInstructionDataEncoder(),
     getRevealStakeCallbackInstructionDataDecoder()
   );
@@ -6086,13 +6139,13 @@ function parseRevealStakeCallbackInstruction(instruction) {
 
 // src/generated/instructions/revealStakeCompDef.ts
 import {
-  combineCodec as combineCodec76,
+  combineCodec as combineCodec75,
   fixDecoderSize as fixDecoderSize27,
   fixEncoderSize as fixEncoderSize28,
   getBytesDecoder as getBytesDecoder27,
   getBytesEncoder as getBytesEncoder28,
-  getStructDecoder as getStructDecoder70,
-  getStructEncoder as getStructEncoder70,
+  getStructDecoder as getStructDecoder69,
+  getStructEncoder as getStructEncoder69,
   transformEncoder as transformEncoder27
 } from "@solana/kit";
 var REVEAL_STAKE_COMP_DEF_DISCRIMINATOR = new Uint8Array([
@@ -6112,7 +6165,7 @@ function getRevealStakeCompDefDiscriminatorBytes() {
 }
 function getRevealStakeCompDefInstructionDataEncoder() {
   return transformEncoder27(
-    getStructEncoder70([["discriminator", fixEncoderSize28(getBytesEncoder28(), 8)]]),
+    getStructEncoder69([["discriminator", fixEncoderSize28(getBytesEncoder28(), 8)]]),
     (value) => ({
       ...value,
       discriminator: REVEAL_STAKE_COMP_DEF_DISCRIMINATOR
@@ -6120,12 +6173,12 @@ function getRevealStakeCompDefInstructionDataEncoder() {
   );
 }
 function getRevealStakeCompDefInstructionDataDecoder() {
-  return getStructDecoder70([
+  return getStructDecoder69([
     ["discriminator", fixDecoderSize27(getBytesDecoder27(), 8)]
   ]);
 }
 function getRevealStakeCompDefInstructionDataCodec() {
-  return combineCodec76(
+  return combineCodec75(
     getRevealStakeCompDefInstructionDataEncoder(),
     getRevealStakeCompDefInstructionDataDecoder()
   );
@@ -6198,13 +6251,13 @@ function parseRevealStakeCompDefInstruction(instruction) {
 
 // src/generated/instructions/setFeeClaimAuthority.ts
 import {
-  combineCodec as combineCodec77,
+  combineCodec as combineCodec76,
   fixDecoderSize as fixDecoderSize28,
   fixEncoderSize as fixEncoderSize29,
   getBytesDecoder as getBytesDecoder28,
   getBytesEncoder as getBytesEncoder29,
-  getStructDecoder as getStructDecoder71,
-  getStructEncoder as getStructEncoder71,
+  getStructDecoder as getStructDecoder70,
+  getStructEncoder as getStructEncoder70,
   transformEncoder as transformEncoder28
 } from "@solana/kit";
 var SET_FEE_CLAIM_AUTHORITY_DISCRIMINATOR = new Uint8Array([
@@ -6224,7 +6277,7 @@ function getSetFeeClaimAuthorityDiscriminatorBytes() {
 }
 function getSetFeeClaimAuthorityInstructionDataEncoder() {
   return transformEncoder28(
-    getStructEncoder71([["discriminator", fixEncoderSize29(getBytesEncoder29(), 8)]]),
+    getStructEncoder70([["discriminator", fixEncoderSize29(getBytesEncoder29(), 8)]]),
     (value) => ({
       ...value,
       discriminator: SET_FEE_CLAIM_AUTHORITY_DISCRIMINATOR
@@ -6232,12 +6285,12 @@ function getSetFeeClaimAuthorityInstructionDataEncoder() {
   );
 }
 function getSetFeeClaimAuthorityInstructionDataDecoder() {
-  return getStructDecoder71([
+  return getStructDecoder70([
     ["discriminator", fixDecoderSize28(getBytesDecoder28(), 8)]
   ]);
 }
 function getSetFeeClaimAuthorityInstructionDataCodec() {
-  return combineCodec77(
+  return combineCodec76(
     getSetFeeClaimAuthorityInstructionDataEncoder(),
     getSetFeeClaimAuthorityInstructionDataDecoder()
   );
@@ -6292,13 +6345,13 @@ function parseSetFeeClaimAuthorityInstruction(instruction) {
 
 // src/generated/instructions/setUpdateAuthority.ts
 import {
-  combineCodec as combineCodec78,
+  combineCodec as combineCodec77,
   fixDecoderSize as fixDecoderSize29,
   fixEncoderSize as fixEncoderSize30,
   getBytesDecoder as getBytesDecoder29,
   getBytesEncoder as getBytesEncoder30,
-  getStructDecoder as getStructDecoder72,
-  getStructEncoder as getStructEncoder72,
+  getStructDecoder as getStructDecoder71,
+  getStructEncoder as getStructEncoder71,
   transformEncoder as transformEncoder29
 } from "@solana/kit";
 var SET_UPDATE_AUTHORITY_DISCRIMINATOR = new Uint8Array([
@@ -6318,17 +6371,17 @@ function getSetUpdateAuthorityDiscriminatorBytes() {
 }
 function getSetUpdateAuthorityInstructionDataEncoder() {
   return transformEncoder29(
-    getStructEncoder72([["discriminator", fixEncoderSize30(getBytesEncoder30(), 8)]]),
+    getStructEncoder71([["discriminator", fixEncoderSize30(getBytesEncoder30(), 8)]]),
     (value) => ({ ...value, discriminator: SET_UPDATE_AUTHORITY_DISCRIMINATOR })
   );
 }
 function getSetUpdateAuthorityInstructionDataDecoder() {
-  return getStructDecoder72([
+  return getStructDecoder71([
     ["discriminator", fixDecoderSize29(getBytesDecoder29(), 8)]
   ]);
 }
 function getSetUpdateAuthorityInstructionDataCodec() {
-  return combineCodec78(
+  return combineCodec77(
     getSetUpdateAuthorityInstructionDataEncoder(),
     getSetUpdateAuthorityInstructionDataDecoder()
   );
@@ -6380,15 +6433,15 @@ function parseSetUpdateAuthorityInstruction(instruction) {
 
 // src/generated/instructions/setWinningOption.ts
 import {
-  combineCodec as combineCodec79,
+  combineCodec as combineCodec78,
   fixDecoderSize as fixDecoderSize30,
   fixEncoderSize as fixEncoderSize31,
-  getAddressEncoder as getAddressEncoder46,
+  getAddressEncoder as getAddressEncoder47,
   getBytesDecoder as getBytesDecoder30,
   getBytesEncoder as getBytesEncoder31,
-  getProgramDerivedAddress as getProgramDerivedAddress14,
-  getStructDecoder as getStructDecoder73,
-  getStructEncoder as getStructEncoder73,
+  getProgramDerivedAddress as getProgramDerivedAddress16,
+  getStructDecoder as getStructDecoder72,
+  getStructEncoder as getStructEncoder72,
   getU16Decoder as getU16Decoder9,
   getU16Encoder as getU16Encoder9,
   getU64Decoder as getU64Decoder38,
@@ -6412,7 +6465,7 @@ function getSetWinningOptionDiscriminatorBytes() {
 }
 function getSetWinningOptionInstructionDataEncoder() {
   return transformEncoder30(
-    getStructEncoder73([
+    getStructEncoder72([
       ["discriminator", fixEncoderSize31(getBytesEncoder31(), 8)],
       ["optionId", getU64Encoder38()],
       ["rewardBp", getU16Encoder9()]
@@ -6421,14 +6474,14 @@ function getSetWinningOptionInstructionDataEncoder() {
   );
 }
 function getSetWinningOptionInstructionDataDecoder() {
-  return getStructDecoder73([
+  return getStructDecoder72([
     ["discriminator", fixDecoderSize30(getBytesDecoder30(), 8)],
     ["optionId", getU64Decoder38()],
     ["rewardBp", getU16Decoder9()]
   ]);
 }
 function getSetWinningOptionInstructionDataCodec() {
-  return combineCodec79(
+  return combineCodec78(
     getSetWinningOptionInstructionDataEncoder(),
     getSetWinningOptionInstructionDataDecoder()
   );
@@ -6446,13 +6499,13 @@ async function getSetWinningOptionInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.option.value) {
-    accounts.option.value = await getProgramDerivedAddress14({
+    accounts.option.value = await getProgramDerivedAddress16({
       programAddress,
       seeds: [
         getBytesEncoder31().encode(
           new Uint8Array([111, 112, 116, 105, 111, 110])
         ),
-        getAddressEncoder46().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder47().encode(expectAddress(accounts.market.value)),
         getU64Encoder38().encode(expectSome(args.optionId))
       ]
     });
@@ -6518,17 +6571,17 @@ function parseSetWinningOptionInstruction(instruction) {
 
 // src/generated/instructions/stake.ts
 import {
-  combineCodec as combineCodec80,
+  combineCodec as combineCodec79,
   fixDecoderSize as fixDecoderSize31,
   fixEncoderSize as fixEncoderSize32,
-  getAddressEncoder as getAddressEncoder47,
+  getAddressEncoder as getAddressEncoder48,
   getArrayDecoder as getArrayDecoder16,
   getArrayEncoder as getArrayEncoder16,
   getBytesDecoder as getBytesDecoder31,
   getBytesEncoder as getBytesEncoder32,
-  getProgramDerivedAddress as getProgramDerivedAddress15,
-  getStructDecoder as getStructDecoder74,
-  getStructEncoder as getStructEncoder74,
+  getProgramDerivedAddress as getProgramDerivedAddress17,
+  getStructDecoder as getStructDecoder73,
+  getStructEncoder as getStructEncoder73,
   getU128Decoder as getU128Decoder6,
   getU128Encoder as getU128Encoder6,
   getU32Decoder as getU32Decoder21,
@@ -6554,7 +6607,7 @@ function getStakeDiscriminatorBytes() {
 }
 function getStakeInstructionDataEncoder() {
   return transformEncoder31(
-    getStructEncoder74([
+    getStructEncoder73([
       ["discriminator", fixEncoderSize32(getBytesEncoder32(), 8)],
       ["computationOffset", getU64Encoder39()],
       ["stakeAccountId", getU32Encoder21()],
@@ -6572,7 +6625,7 @@ function getStakeInstructionDataEncoder() {
   );
 }
 function getStakeInstructionDataDecoder() {
-  return getStructDecoder74([
+  return getStructDecoder73([
     ["discriminator", fixDecoderSize31(getBytesDecoder31(), 8)],
     ["computationOffset", getU64Decoder39()],
     ["stakeAccountId", getU32Decoder21()],
@@ -6585,7 +6638,7 @@ function getStakeInstructionDataDecoder() {
   ]);
 }
 function getStakeInstructionDataCodec() {
-  return combineCodec80(
+  return combineCodec79(
     getStakeInstructionDataEncoder(),
     getStakeInstructionDataDecoder()
   );
@@ -6622,17 +6675,17 @@ async function getStakeInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.marketTokenAta.value) {
-    accounts.marketTokenAta.value = await getProgramDerivedAddress15({
+    accounts.marketTokenAta.value = await getProgramDerivedAddress17({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder47().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder47().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder47().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder48().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder48().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder48().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
   if (!accounts.signPdaAccount.value) {
-    accounts.signPdaAccount.value = await getProgramDerivedAddress15({
+    accounts.signPdaAccount.value = await getProgramDerivedAddress17({
       programAddress,
       seeds: [
         getBytesEncoder32().encode(
@@ -6813,7 +6866,7 @@ function parseStakeInstruction(instruction) {
 
 // src/generated/instructions/stakeCallback.ts
 import {
-  combineCodec as combineCodec81,
+  combineCodec as combineCodec80,
   fixDecoderSize as fixDecoderSize32,
   fixEncoderSize as fixEncoderSize33,
   getArrayDecoder as getArrayDecoder17,
@@ -6822,8 +6875,8 @@ import {
   getBytesEncoder as getBytesEncoder33,
   getDiscriminatedUnionDecoder as getDiscriminatedUnionDecoder5,
   getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder5,
-  getStructDecoder as getStructDecoder75,
-  getStructEncoder as getStructEncoder75,
+  getStructDecoder as getStructDecoder74,
+  getStructEncoder as getStructEncoder74,
   getTupleDecoder as getTupleDecoder7,
   getTupleEncoder as getTupleEncoder7,
   getU8Decoder as getU8Decoder24,
@@ -6849,14 +6902,14 @@ function getStakeCallbackDiscriminatorBytes() {
 }
 function getStakeCallbackInstructionDataEncoder() {
   return transformEncoder32(
-    getStructEncoder75([
+    getStructEncoder74([
       ["discriminator", fixEncoderSize33(getBytesEncoder33(), 8)],
       [
         "output",
         getDiscriminatedUnionEncoder5([
           [
             "Success",
-            getStructEncoder75([
+            getStructEncoder74([
               [
                 "fields",
                 getTupleEncoder7([
@@ -6869,7 +6922,7 @@ function getStakeCallbackInstructionDataEncoder() {
           ["Failure", getUnitEncoder2()],
           [
             "MarkerForIdlBuildDoNotUseThis",
-            getStructEncoder75([
+            getStructEncoder74([
               ["fields", getTupleEncoder7([getStakeOutputEncoder()])]
             ])
           ]
@@ -6880,14 +6933,14 @@ function getStakeCallbackInstructionDataEncoder() {
   );
 }
 function getStakeCallbackInstructionDataDecoder() {
-  return getStructDecoder75([
+  return getStructDecoder74([
     ["discriminator", fixDecoderSize32(getBytesDecoder32(), 8)],
     [
       "output",
       getDiscriminatedUnionDecoder5([
         [
           "Success",
-          getStructDecoder75([
+          getStructDecoder74([
             [
               "fields",
               getTupleDecoder7([
@@ -6900,7 +6953,7 @@ function getStakeCallbackInstructionDataDecoder() {
         ["Failure", getUnitDecoder2()],
         [
           "MarkerForIdlBuildDoNotUseThis",
-          getStructDecoder75([
+          getStructDecoder74([
             ["fields", getTupleDecoder7([getStakeOutputDecoder()])]
           ])
         ]
@@ -6909,7 +6962,7 @@ function getStakeCallbackInstructionDataDecoder() {
   ]);
 }
 function getStakeCallbackInstructionDataCodec() {
-  return combineCodec81(
+  return combineCodec80(
     getStakeCallbackInstructionDataEncoder(),
     getStakeCallbackInstructionDataDecoder()
   );
@@ -6986,13 +7039,13 @@ function parseStakeCallbackInstruction(instruction) {
 
 // src/generated/instructions/stakeCompDef.ts
 import {
-  combineCodec as combineCodec82,
+  combineCodec as combineCodec81,
   fixDecoderSize as fixDecoderSize33,
   fixEncoderSize as fixEncoderSize34,
   getBytesDecoder as getBytesDecoder33,
   getBytesEncoder as getBytesEncoder34,
-  getStructDecoder as getStructDecoder76,
-  getStructEncoder as getStructEncoder76,
+  getStructDecoder as getStructDecoder75,
+  getStructEncoder as getStructEncoder75,
   transformEncoder as transformEncoder33
 } from "@solana/kit";
 var STAKE_COMP_DEF_DISCRIMINATOR = new Uint8Array([
@@ -7012,17 +7065,17 @@ function getStakeCompDefDiscriminatorBytes() {
 }
 function getStakeCompDefInstructionDataEncoder() {
   return transformEncoder33(
-    getStructEncoder76([["discriminator", fixEncoderSize34(getBytesEncoder34(), 8)]]),
+    getStructEncoder75([["discriminator", fixEncoderSize34(getBytesEncoder34(), 8)]]),
     (value) => ({ ...value, discriminator: STAKE_COMP_DEF_DISCRIMINATOR })
   );
 }
 function getStakeCompDefInstructionDataDecoder() {
-  return getStructDecoder76([
+  return getStructDecoder75([
     ["discriminator", fixDecoderSize33(getBytesDecoder33(), 8)]
   ]);
 }
 function getStakeCompDefInstructionDataCodec() {
-  return combineCodec82(
+  return combineCodec81(
     getStakeCompDefInstructionDataEncoder(),
     getStakeCompDefInstructionDataDecoder()
   );
@@ -7093,15 +7146,15 @@ function parseStakeCompDefInstruction(instruction) {
 
 // src/generated/instructions/unstake.ts
 import {
-  combineCodec as combineCodec83,
+  combineCodec as combineCodec82,
   fixDecoderSize as fixDecoderSize34,
   fixEncoderSize as fixEncoderSize35,
-  getAddressEncoder as getAddressEncoder48,
+  getAddressEncoder as getAddressEncoder49,
   getBytesDecoder as getBytesDecoder34,
   getBytesEncoder as getBytesEncoder35,
-  getProgramDerivedAddress as getProgramDerivedAddress16,
-  getStructDecoder as getStructDecoder77,
-  getStructEncoder as getStructEncoder77,
+  getProgramDerivedAddress as getProgramDerivedAddress18,
+  getStructDecoder as getStructDecoder76,
+  getStructEncoder as getStructEncoder76,
   getU32Decoder as getU32Decoder22,
   getU32Encoder as getU32Encoder22,
   transformEncoder as transformEncoder34
@@ -7121,7 +7174,7 @@ function getUnstakeDiscriminatorBytes() {
 }
 function getUnstakeInstructionDataEncoder() {
   return transformEncoder34(
-    getStructEncoder77([
+    getStructEncoder76([
       ["discriminator", fixEncoderSize35(getBytesEncoder35(), 8)],
       ["stakeAccountId", getU32Encoder22()]
     ]),
@@ -7129,13 +7182,13 @@ function getUnstakeInstructionDataEncoder() {
   );
 }
 function getUnstakeInstructionDataDecoder() {
-  return getStructDecoder77([
+  return getStructDecoder76([
     ["discriminator", fixDecoderSize34(getBytesDecoder34(), 8)],
     ["stakeAccountId", getU32Decoder22()]
   ]);
 }
 function getUnstakeInstructionDataCodec() {
-  return combineCodec83(
+  return combineCodec82(
     getUnstakeInstructionDataEncoder(),
     getUnstakeInstructionDataDecoder()
   );
@@ -7159,7 +7212,7 @@ async function getUnstakeInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.stakeAccount.value) {
-    accounts.stakeAccount.value = await getProgramDerivedAddress16({
+    accounts.stakeAccount.value = await getProgramDerivedAddress18({
       programAddress,
       seeds: [
         getBytesEncoder35().encode(
@@ -7179,19 +7232,19 @@ async function getUnstakeInstructionAsync(input, config) {
             116
           ])
         ),
-        getAddressEncoder48().encode(expectAddress(accounts.owner.value)),
-        getAddressEncoder48().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder49().encode(expectAddress(accounts.owner.value)),
+        getAddressEncoder49().encode(expectAddress(accounts.market.value)),
         getU32Encoder22().encode(expectSome(args.stakeAccountId))
       ]
     });
   }
   if (!accounts.marketTokenAta.value) {
-    accounts.marketTokenAta.value = await getProgramDerivedAddress16({
+    accounts.marketTokenAta.value = await getProgramDerivedAddress18({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder48().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder48().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder48().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder49().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder49().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder49().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -7286,13 +7339,15 @@ function parseUnstakeInstruction(instruction) {
 
 // src/generated/instructions/updatePlatformConfig.ts
 import {
-  combineCodec as combineCodec84,
+  combineCodec as combineCodec83,
   fixDecoderSize as fixDecoderSize35,
   fixEncoderSize as fixEncoderSize36,
+  getAddressDecoder as getAddressDecoder34,
+  getAddressEncoder as getAddressEncoder50,
   getBytesDecoder as getBytesDecoder35,
   getBytesEncoder as getBytesEncoder36,
-  getStructDecoder as getStructDecoder78,
-  getStructEncoder as getStructEncoder78,
+  getStructDecoder as getStructDecoder77,
+  getStructEncoder as getStructEncoder77,
   getU16Decoder as getU16Decoder10,
   getU16Encoder as getU16Encoder10,
   getU64Decoder as getU64Decoder40,
@@ -7316,14 +7371,14 @@ function getUpdatePlatformConfigDiscriminatorBytes() {
 }
 function getUpdatePlatformConfigInstructionDataEncoder() {
   return transformEncoder35(
-    getStructEncoder78([
+    getStructEncoder77([
       ["discriminator", fixEncoderSize36(getBytesEncoder36(), 8)],
       ["platformFeeBp", getU16Encoder10()],
       ["rewardPoolFeeBp", getU16Encoder10()],
       ["creatorFeeBp", getU16Encoder10()],
+      ["revealAuthority", getAddressEncoder50()],
       ["minTimeToStakeSeconds", getU64Encoder40()],
-      ["minRevealPeriodSeconds", getU64Encoder40()],
-      ["maxRevealPeriodSeconds", getU64Encoder40()],
+      ["revealPeriodSeconds", getU64Encoder40()],
       ["marketResolutionDeadlineSeconds", getU64Encoder40()]
     ]),
     (value) => ({
@@ -7333,19 +7388,19 @@ function getUpdatePlatformConfigInstructionDataEncoder() {
   );
 }
 function getUpdatePlatformConfigInstructionDataDecoder() {
-  return getStructDecoder78([
+  return getStructDecoder77([
     ["discriminator", fixDecoderSize35(getBytesDecoder35(), 8)],
     ["platformFeeBp", getU16Decoder10()],
     ["rewardPoolFeeBp", getU16Decoder10()],
     ["creatorFeeBp", getU16Decoder10()],
+    ["revealAuthority", getAddressDecoder34()],
     ["minTimeToStakeSeconds", getU64Decoder40()],
-    ["minRevealPeriodSeconds", getU64Decoder40()],
-    ["maxRevealPeriodSeconds", getU64Decoder40()],
+    ["revealPeriodSeconds", getU64Decoder40()],
     ["marketResolutionDeadlineSeconds", getU64Decoder40()]
   ]);
 }
 function getUpdatePlatformConfigInstructionDataCodec() {
-  return combineCodec84(
+  return combineCodec83(
     getUpdatePlatformConfigInstructionDataEncoder(),
     getUpdatePlatformConfigInstructionDataDecoder()
   );
@@ -7397,15 +7452,15 @@ function parseUpdatePlatformConfigInstruction(instruction) {
 
 // src/generated/instructions/withdrawReward.ts
 import {
-  combineCodec as combineCodec85,
+  combineCodec as combineCodec84,
   fixDecoderSize as fixDecoderSize36,
   fixEncoderSize as fixEncoderSize37,
-  getAddressEncoder as getAddressEncoder49,
+  getAddressEncoder as getAddressEncoder51,
   getBytesDecoder as getBytesDecoder36,
   getBytesEncoder as getBytesEncoder37,
-  getProgramDerivedAddress as getProgramDerivedAddress17,
-  getStructDecoder as getStructDecoder79,
-  getStructEncoder as getStructEncoder79,
+  getProgramDerivedAddress as getProgramDerivedAddress19,
+  getStructDecoder as getStructDecoder78,
+  getStructEncoder as getStructEncoder78,
   transformEncoder as transformEncoder36
 } from "@solana/kit";
 var WITHDRAW_REWARD_DISCRIMINATOR = new Uint8Array([
@@ -7425,17 +7480,17 @@ function getWithdrawRewardDiscriminatorBytes() {
 }
 function getWithdrawRewardInstructionDataEncoder() {
   return transformEncoder36(
-    getStructEncoder79([["discriminator", fixEncoderSize37(getBytesEncoder37(), 8)]]),
+    getStructEncoder78([["discriminator", fixEncoderSize37(getBytesEncoder37(), 8)]]),
     (value) => ({ ...value, discriminator: WITHDRAW_REWARD_DISCRIMINATOR })
   );
 }
 function getWithdrawRewardInstructionDataDecoder() {
-  return getStructDecoder79([
+  return getStructDecoder78([
     ["discriminator", fixDecoderSize36(getBytesDecoder36(), 8)]
   ]);
 }
 function getWithdrawRewardInstructionDataCodec() {
-  return combineCodec85(
+  return combineCodec84(
     getWithdrawRewardInstructionDataEncoder(),
     getWithdrawRewardInstructionDataDecoder()
   );
@@ -7456,24 +7511,24 @@ async function getWithdrawRewardInstructionAsync(input, config) {
   };
   const accounts = originalAccounts;
   if (!accounts.sponsorAccount.value) {
-    accounts.sponsorAccount.value = await getProgramDerivedAddress17({
+    accounts.sponsorAccount.value = await getProgramDerivedAddress19({
       programAddress,
       seeds: [
         getBytesEncoder37().encode(
           new Uint8Array([115, 112, 111, 110, 115, 111, 114])
         ),
-        getAddressEncoder49().encode(expectAddress(accounts.sponsor.value)),
-        getAddressEncoder49().encode(expectAddress(accounts.market.value))
+        getAddressEncoder51().encode(expectAddress(accounts.sponsor.value)),
+        getAddressEncoder51().encode(expectAddress(accounts.market.value))
       ]
     });
   }
   if (!accounts.marketTokenAta.value) {
-    accounts.marketTokenAta.value = await getProgramDerivedAddress17({
+    accounts.marketTokenAta.value = await getProgramDerivedAddress19({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder49().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder49().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder49().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder51().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder51().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder51().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -7687,6 +7742,44 @@ function getComputeAccounts(ixName, config) {
   };
 }
 
+// src/arcium/awaitFinalizeComputation.ts
+var TIMEOUT_SLOTS = 180;
+var DEFAULT_POLL_INTERVAL = 1e3;
+var DEFAULT_SIGNATURE_LIMIT = 100;
+var awaitComputationFinalization = async (rpc, computationAccount, invocationSignature, options) => {
+  const commitment = options?.commitment ?? "confirmed";
+  const pollInterval = options?.pollInterval ?? DEFAULT_POLL_INTERVAL;
+  const limit = options?.transactionCountLimit ?? DEFAULT_SIGNATURE_LIMIT;
+  const invocationTx = await rpc.getTransaction(invocationSignature, {
+    commitment,
+    encoding: "json",
+    maxSupportedTransactionVersion: 0
+  }).send();
+  if (!invocationTx) {
+    throw new Error(`Invocation transaction ${invocationSignature} not found`);
+  }
+  const deadlineSlot = invocationTx.slot + BigInt(TIMEOUT_SLOTS);
+  for (; ; ) {
+    const signatures = await rpc.getSignaturesForAddress(computationAccount, {
+      limit,
+      commitment
+    }).send();
+    for (const sigInfo of signatures) {
+      if (sigInfo.signature === invocationSignature) continue;
+      if (sigInfo.err === null) {
+        return sigInfo.signature;
+      }
+    }
+    const currentSlot = await rpc.getSlot({ commitment }).send();
+    if (currentSlot > deadlineSlot) {
+      throw new Error(
+        `Computation ${computationAccount} not finalized within ${TIMEOUT_SLOTS} slots of invocation ${invocationSignature}`
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+  }
+};
+
 // src/instructions/stake.ts
 async function stake(input, config) {
   const {
@@ -7727,6 +7820,10 @@ async function stake(input, config) {
     programAddress ? { programAddress } : void 0
   );
 }
+async function awaitStakeFinalization(rpc, txSignature, config, options) {
+  const { computationAccount } = getComputeAccounts("stake", config);
+  return awaitComputationFinalization(rpc, computationAccount, txSignature, options);
+}
 
 // src/instructions/revealStake.ts
 async function revealStake(input, config) {
@@ -7742,6 +7839,10 @@ async function revealStake(input, config) {
     programAddress ? { programAddress } : void 0
   );
 }
+async function awaitRevealStakeFinalization(rpc, txSignature, config, options) {
+  const { computationAccount } = getComputeAccounts("reveal_stake", config);
+  return awaitComputationFinalization(rpc, computationAccount, txSignature, options);
+}
 
 // src/instructions/addMarketOption.ts
 async function addMarketOption(input) {
@@ -7761,24 +7862,6 @@ function openMarket(input) {
   );
 }
 
-// src/instructions/pauseStaking.ts
-function pauseStaking(input) {
-  const { programAddress, ...params } = input;
-  return getPauseStakingInstruction(
-    params,
-    programAddress ? { programAddress } : void 0
-  );
-}
-
-// src/instructions/resumeStaking.ts
-function resumeStaking(input) {
-  const { programAddress, ...params } = input;
-  return getResumeStakingInstruction(
-    params,
-    programAddress ? { programAddress } : void 0
-  );
-}
-
 // src/instructions/setWinningOption.ts
 async function setWinningOption(input) {
   const { programAddress, ...params } = input;
@@ -7833,6 +7916,15 @@ async function initAllowedMint(input) {
   );
 }
 
+// src/instructions/claimRewards.ts
+async function claimRewards(input) {
+  const { programAddress, ...params } = input;
+  return getClaimRewardsInstructionAsync(
+    params,
+    programAddress ? { programAddress } : void 0
+  );
+}
+
 // src/instructions/closeStakeAccount.ts
 async function closeStakeAccount(input) {
   const { programAddress, ...params } = input;
@@ -7842,6 +7934,15 @@ async function closeStakeAccount(input) {
   );
 }
 
+// src/instructions/closeUnrevealedStakeAccount.ts
+async function closeUnrevealedStakeAccount(input) {
+  const { programAddress, ...params } = input;
+  return getCloseUnrevealedStakeAccountInstructionAsync(
+    params,
+    programAddress ? { programAddress } : void 0
+  );
+}
+
 // src/instructions/closeStuckStakeAccount.ts
 async function closeStuckStakeAccount(input) {
   const { programAddress, ...params } = input;
@@ -7880,17 +7981,17 @@ async function finalizeRevealStake(input) {
 
 // src/accounts/platformConfig.ts
 import {
-  getAddressEncoder as getAddressEncoder50,
-  getProgramDerivedAddress as getProgramDerivedAddress18,
+  getAddressEncoder as getAddressEncoder52,
+  getProgramDerivedAddress as getProgramDerivedAddress20,
   getUtf8Encoder as getUtf8Encoder4
 } from "@solana/kit";
 var PLATFORM_CONFIG_SEED = "platform_config";
 async function getPlatformConfigAddress(authority, name, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
-  return getProgramDerivedAddress18({
+  return getProgramDerivedAddress20({
     programAddress: programId,
     seeds: [
       PLATFORM_CONFIG_SEED,
-      getAddressEncoder50().encode(authority),
+      getAddressEncoder52().encode(authority),
       getUtf8Encoder4().encode(name)
     ]
   });
@@ -7906,9 +8007,9 @@ async function createPlatformConfig(rpc, params) {
     rewardPoolFeeBp,
     creatorFeeBp,
     feeClaimAuthority,
+    revealAuthority,
     minTimeToStakeSeconds,
-    minRevealPeriodSeconds,
-    maxRevealPeriodSeconds,
+    revealPeriodSeconds,
     marketResolutionDeadlineSeconds
   } = params;
   const [platformConfigAddress] = await getPlatformConfigAddress(
@@ -7930,9 +8031,9 @@ async function createPlatformConfig(rpc, params) {
       rewardPoolFeeBp,
       creatorFeeBp,
       feeClaimAuthority,
+      revealAuthority,
       minTimeToStakeSeconds,
-      minRevealPeriodSeconds,
-      maxRevealPeriodSeconds,
+      revealPeriodSeconds,
       marketResolutionDeadlineSeconds
     },
     programAddress ? { programAddress } : void 0
@@ -7948,9 +8049,9 @@ async function updatePlatformConfig(rpc, params) {
     platformFeeBp,
     rewardPoolFeeBp,
     creatorFeeBp,
+    revealAuthority,
     minTimeToStakeSeconds,
-    minRevealPeriodSeconds,
-    maxRevealPeriodSeconds,
+    revealPeriodSeconds,
     marketResolutionDeadlineSeconds
   } = params;
   const [platformConfigAddress] = await getPlatformConfigAddress(
@@ -7971,9 +8072,9 @@ async function updatePlatformConfig(rpc, params) {
       platformFeeBp,
       rewardPoolFeeBp,
       creatorFeeBp,
+      revealAuthority,
       minTimeToStakeSeconds,
-      minRevealPeriodSeconds,
-      maxRevealPeriodSeconds,
+      revealPeriodSeconds,
       marketResolutionDeadlineSeconds
     },
     programAddress ? { programAddress } : void 0
@@ -8027,13 +8128,13 @@ function setFeeClaimAuthority(input) {
 
 // src/accounts/allowedMint.ts
 import {
-  getAddressEncoder as getAddressEncoder51,
-  getProgramDerivedAddress as getProgramDerivedAddress19
+  getAddressEncoder as getAddressEncoder53,
+  getProgramDerivedAddress as getProgramDerivedAddress21
 } from "@solana/kit";
 var ALLOWED_MINT_SEED = "allowed_mint";
 async function getAllowedMintAddress(platformConfig, mint, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
-  const enc = getAddressEncoder51();
-  return getProgramDerivedAddress19({
+  const enc = getAddressEncoder53();
+  return getProgramDerivedAddress21({
     programAddress: programId,
     seeds: [ALLOWED_MINT_SEED, enc.encode(platformConfig), enc.encode(mint)]
   });
@@ -8041,18 +8142,18 @@ async function getAllowedMintAddress(platformConfig, mint, programId = OPPORTUNI
 
 // src/accounts/opportunityMarket.ts
 import {
-  getAddressEncoder as getAddressEncoder52,
+  getAddressEncoder as getAddressEncoder54,
   getU64Encoder as getU64Encoder41,
-  getProgramDerivedAddress as getProgramDerivedAddress20
+  getProgramDerivedAddress as getProgramDerivedAddress22
 } from "@solana/kit";
 var OPPORTUNITY_MARKET_SEED = "opportunity_market";
 async function getOpportunityMarketAddress(platformConfig, creator, marketIndex, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
-  return getProgramDerivedAddress20({
+  return getProgramDerivedAddress22({
     programAddress: programId,
     seeds: [
       OPPORTUNITY_MARKET_SEED,
-      getAddressEncoder52().encode(platformConfig),
-      getAddressEncoder52().encode(creator),
+      getAddressEncoder54().encode(platformConfig),
+      getAddressEncoder54().encode(creator),
       getU64Encoder41().encode(BigInt(marketIndex))
     ]
   });
@@ -8060,17 +8161,17 @@ async function getOpportunityMarketAddress(platformConfig, creator, marketIndex,
 
 // src/accounts/opportunityMarketOption.ts
 import {
-  getAddressEncoder as getAddressEncoder53,
+  getAddressEncoder as getAddressEncoder55,
   getU64Encoder as getU64Encoder42,
-  getProgramDerivedAddress as getProgramDerivedAddress21
+  getProgramDerivedAddress as getProgramDerivedAddress23
 } from "@solana/kit";
 var OPPORTUNITY_MARKET_OPTION_SEED = "option";
 async function getOpportunityMarketOptionAddress(market, optionId, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
-  return getProgramDerivedAddress21({
+  return getProgramDerivedAddress23({
     programAddress: programId,
     seeds: [
       OPPORTUNITY_MARKET_OPTION_SEED,
-      getAddressEncoder53().encode(market),
+      getAddressEncoder55().encode(market),
       getU64Encoder42().encode(optionId)
     ]
   });
@@ -8078,13 +8179,13 @@ async function getOpportunityMarketOptionAddress(market, optionId, programId = O
 
 // src/accounts/opportunityMarketSponsor.ts
 import {
-  getAddressEncoder as getAddressEncoder54,
-  getProgramDerivedAddress as getProgramDerivedAddress22
+  getAddressEncoder as getAddressEncoder56,
+  getProgramDerivedAddress as getProgramDerivedAddress24
 } from "@solana/kit";
 var SPONSOR_SEED = "sponsor";
 async function getOpportunityMarketSponsorAddress(sponsor, market, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
-  const addressEncoder = getAddressEncoder54();
-  return getProgramDerivedAddress22({
+  const addressEncoder = getAddressEncoder56();
+  return getProgramDerivedAddress24({
     programAddress: programId,
     seeds: [
       SPONSOR_SEED,
@@ -8096,15 +8197,15 @@ async function getOpportunityMarketSponsorAddress(sponsor, market, programId = O
 
 // src/accounts/stakeAccount.ts
 import {
-  getAddressEncoder as getAddressEncoder55,
-  getProgramDerivedAddress as getProgramDerivedAddress23
+  getAddressEncoder as getAddressEncoder57,
+  getProgramDerivedAddress as getProgramDerivedAddress25
 } from "@solana/kit";
 var STAKE_ACCOUNT_SEED = "stake_account";
 async function getStakeAccountAddress(owner, market, stakeAccountId, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
-  const addressEncoder = getAddressEncoder55();
+  const addressEncoder = getAddressEncoder57();
   const idBytes = new Uint8Array(4);
   new DataView(idBytes.buffer).setUint32(0, stakeAccountId, true);
-  return getProgramDerivedAddress23({
+  return getProgramDerivedAddress25({
     programAddress: programId,
     seeds: [
       STAKE_ACCOUNT_SEED,
@@ -8115,115 +8216,6 @@ async function getStakeAccountAddress(owner, market, stakeAccountId, programId =
   });
 }
 
-// src/arcium/awaitFinalizeComputation.ts
-import { getAddressEncoder as getAddressEncoder56 } from "@solana/kit";
-
-// src/arcium/constants.ts
-var ARCIUM_PROGRAM_ID = "Arcj82pX7HxYKLR92qvgZUAd7vGS1k4hQvAFcPATFdEQ";
-
-// src/arcium/awaitFinalizeComputation.ts
-var FINALIZE_COMPUTATION_EVENT_DISCRIMINATOR = new Uint8Array([27, 75, 117, 221, 191, 213, 253, 249]);
-function serializeLE(val, lengthInBytes) {
-  const result = new Uint8Array(lengthInBytes);
-  let tempVal = val;
-  for (let i = 0; i < lengthInBytes; i++) {
-    result[i] = Number(tempVal & BigInt(255));
-    tempVal >>= BigInt(8);
-  }
-  return result;
-}
-function bytesEqual(a, b) {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) return false;
-  }
-  return true;
-}
-var awaitBatchComputationFinalization = async (rpc, computationOffsets, options) => {
-  if (computationOffsets.length === 0) {
-    return /* @__PURE__ */ new Map();
-  }
-  const mxeProgramId = options?.mxeProgramId ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
-  const commitment = options?.commitment ?? "confirmed";
-  const mxeProgramIdBytes = getAddressEncoder56().encode(mxeProgramId);
-  const transactionCountLimit = options?.transactionCountLimit ?? 100;
-  const pollInterval = options?.pollInterval ?? 1e3;
-  const maxAttempts = options?.maxAttempts ?? 120;
-  const offsetBytesMap = /* @__PURE__ */ new Map();
-  for (const offset of computationOffsets) {
-    offsetBytesMap.set(offset, serializeLE(offset, 8));
-  }
-  const foundResults = /* @__PURE__ */ new Map();
-  const remainingOffsets = new Set(computationOffsets);
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    try {
-      const signatures = await rpc.getSignaturesForAddress(
-        ARCIUM_PROGRAM_ID,
-        { limit: transactionCountLimit }
-      ).send();
-      for (const sigInfo of signatures) {
-        const tx = await rpc.getTransaction(sigInfo.signature, {
-          commitment,
-          encoding: "json",
-          maxSupportedTransactionVersion: 0
-        }).send();
-        if (!tx) continue;
-        const logs = tx.meta?.logMessages || [];
-        for (const log of logs) {
-          if (log.includes("Program data:")) {
-            const base64Data = log.split("Program data: ")[1];
-            if (!base64Data) continue;
-            try {
-              const eventData = Uint8Array.from(atob(base64Data), (c) => c.charCodeAt(0));
-              if (eventData.length >= 48 && bytesEqual(eventData.subarray(0, 8), FINALIZE_COMPUTATION_EVENT_DISCRIMINATOR)) {
-                const eventOffsetBytes = eventData.subarray(8, 16);
-                const eventMxeProgramId = eventData.subarray(16, 48);
-                if (!bytesEqual(eventMxeProgramId, mxeProgramIdBytes)) continue;
-                for (const offset of remainingOffsets) {
-                  const expectedBytes = offsetBytesMap.get(offset);
-                  if (bytesEqual(eventOffsetBytes, expectedBytes)) {
-                    const txError = tx.meta?.err;
-                    let errorMessage;
-                    if (txError) {
-                      const errorLog = logs.find((l) => l.includes("Error") || l.includes("failed"));
-                      errorMessage = errorLog || JSON.stringify(txError);
-                    }
-                    foundResults.set(offset, {
-                      signature: sigInfo.signature,
-                      error: errorMessage
-                    });
-                    remainingOffsets.delete(offset);
-                    break;
-                  }
-                }
-              }
-            } catch {
-              continue;
-            }
-          }
-        }
-        if (remainingOffsets.size === 0) {
-          return foundResults;
-        }
-      }
-      if (remainingOffsets.size === 0) {
-        return foundResults;
-      }
-      await new Promise((resolve) => setTimeout(resolve, pollInterval));
-    } catch (error) {
-      await new Promise((resolve) => setTimeout(resolve, pollInterval));
-    }
-  }
-  const missingOffsets = Array.from(remainingOffsets).join(", ");
-  throw new Error(
-    `Computation finalization timed out after ${maxAttempts} attempts. Missing offsets: ${missingOffsets}`
-  );
-};
-var awaitComputationFinalization = async (rpc, computationOffset, options) => {
-  const results = await awaitBatchComputationFinalization(rpc, [computationOffset], options);
-  return results.get(computationOffset);
-};
-
 // src/x25519/keypair.ts
 import { RescueCipher, x25519 } from "@arcium-hq/client";
 import { BN as BN3 } from "bn.js";
@@ -8257,9 +8249,11 @@ export {
   ARCIUM_SIGNER_ACCOUNT_DISCRIMINATOR,
   CLAIM_CREATOR_FEES_DISCRIMINATOR,
   CLAIM_FEES_DISCRIMINATOR,
+  CLAIM_REWARDS_DISCRIMINATOR,
   CLOSE_OPTION_ACCOUNT_DISCRIMINATOR,
   CLOSE_STAKE_ACCOUNT_DISCRIMINATOR,
   CLOSE_STUCK_STAKE_ACCOUNT_DISCRIMINATOR,
+  CLOSE_UNREVEALED_STAKE_ACCOUNT_DISCRIMINATOR,
   CREATE_MARKET_DISCRIMINATOR,
   END_REVEAL_PERIOD_DISCRIMINATOR,
   FINALIZE_REVEAL_STAKE_DISCRIMINATOR,
@@ -8287,11 +8281,10 @@ 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__NO_FINALIZED_WINNING_OPTION,
   OPPORTUNITY_MARKET_ERROR__NO_REWARD_TO_CLAIM,
   OPPORTUNITY_MARKET_ERROR__NO_STAKE,
   OPPORTUNITY_MARKET_ERROR__OPTION_STILL_NEEDED,
@@ -8314,12 +8307,10 @@ export {
   OpportunityMarketAccount,
   OpportunityMarketInstruction,
   Output,
-  PAUSE_STAKING_DISCRIMINATOR,
   PLATFORM_CONFIG_DISCRIMINATOR,
   PLATFORM_CONFIG_SEED,
   Parameter,
   RESOLVE_MARKET_DISCRIMINATOR,
-  RESUME_STAKING_DISCRIMINATOR,
   REVEAL_STAKE_CALLBACK_DISCRIMINATOR,
   REVEAL_STAKE_COMP_DEF_DISCRIMINATOR,
   REVEAL_STAKE_DISCRIMINATOR,
@@ -8337,14 +8328,17 @@ export {
   WITHDRAW_REWARD_DISCRIMINATOR,
   addMarketOption,
   addReward,
-  awaitBatchComputationFinalization,
   awaitComputationFinalization,
+  awaitRevealStakeFinalization,
+  awaitStakeFinalization,
   circuitSource,
   claimCreatorFees,
   claimFees,
+  claimRewards,
   closeOptionAccount,
   closeStakeAccount,
   closeStuckStakeAccount,
+  closeUnrevealedStakeAccount,
   createCipher,
   createMarket,
   createPlatformConfig,
@@ -8433,6 +8427,12 @@ export {
   getClaimFeesInstructionDataCodec,
   getClaimFeesInstructionDataDecoder,
   getClaimFeesInstructionDataEncoder,
+  getClaimRewardsDiscriminatorBytes,
+  getClaimRewardsInstruction,
+  getClaimRewardsInstructionAsync,
+  getClaimRewardsInstructionDataCodec,
+  getClaimRewardsInstructionDataDecoder,
+  getClaimRewardsInstructionDataEncoder,
   getClockAccountCodec,
   getClockAccountDecoder,
   getClockAccountEncoder,
@@ -8454,6 +8454,12 @@ export {
   getCloseStuckStakeAccountInstructionDataCodec,
   getCloseStuckStakeAccountInstructionDataDecoder,
   getCloseStuckStakeAccountInstructionDataEncoder,
+  getCloseUnrevealedStakeAccountDiscriminatorBytes,
+  getCloseUnrevealedStakeAccountInstruction,
+  getCloseUnrevealedStakeAccountInstructionAsync,
+  getCloseUnrevealedStakeAccountInstructionDataCodec,
+  getCloseUnrevealedStakeAccountInstructionDataDecoder,
+  getCloseUnrevealedStakeAccountInstructionDataEncoder,
   getClusterCodec,
   getClusterDecoder,
   getClusterEncoder,
@@ -8589,11 +8595,6 @@ export {
   getParameterCodec,
   getParameterDecoder,
   getParameterEncoder,
-  getPauseStakingDiscriminatorBytes,
-  getPauseStakingInstruction,
-  getPauseStakingInstructionDataCodec,
-  getPauseStakingInstructionDataDecoder,
-  getPauseStakingInstructionDataEncoder,
   getPlatformConfigAddress,
   getPlatformConfigCodec,
   getPlatformConfigDecoder,
@@ -8604,11 +8605,6 @@ export {
   getResolveMarketInstructionDataCodec,
   getResolveMarketInstructionDataDecoder,
   getResolveMarketInstructionDataEncoder,
-  getResumeStakingDiscriminatorBytes,
-  getResumeStakingInstruction,
-  getResumeStakingInstructionDataCodec,
-  getResumeStakingInstructionDataDecoder,
-  getResumeStakingInstructionDataEncoder,
   getRevealPeriodEndedEventCodec,
   getRevealPeriodEndedEventDecoder,
   getRevealPeriodEndedEventEncoder,
@@ -8640,6 +8636,9 @@ export {
   getRewardWithdrawnEventCodec,
   getRewardWithdrawnEventDecoder,
   getRewardWithdrawnEventEncoder,
+  getRewardsClaimedEventCodec,
+  getRewardsClaimedEventDecoder,
+  getRewardsClaimedEventEncoder,
   getSetFeeClaimAuthorityDiscriminatorBytes,
   getSetFeeClaimAuthorityInstruction,
   getSetFeeClaimAuthorityInstructionDataCodec,
@@ -8695,12 +8694,6 @@ export {
   getStakedEventCodec,
   getStakedEventDecoder,
   getStakedEventEncoder,
-  getStakingPausedEventCodec,
-  getStakingPausedEventDecoder,
-  getStakingPausedEventEncoder,
-  getStakingResumedEventCodec,
-  getStakingResumedEventDecoder,
-  getStakingResumedEventEncoder,
   getStuckStakeClosedEventCodec,
   getStuckStakeClosedEventDecoder,
   getStuckStakeClosedEventEncoder,
@@ -8748,9 +8741,11 @@ export {
   parseAddRewardInstruction,
   parseClaimCreatorFeesInstruction,
   parseClaimFeesInstruction,
+  parseClaimRewardsInstruction,
   parseCloseOptionAccountInstruction,
   parseCloseStakeAccountInstruction,
   parseCloseStuckStakeAccountInstruction,
+  parseCloseUnrevealedStakeAccountInstruction,
   parseCreateMarketInstruction,
   parseEndRevealPeriodInstruction,
   parseFinalizeRevealStakeInstruction,
@@ -8758,9 +8753,7 @@ export {
   parseInitPlatformConfigInstruction,
   parseInitStakeAccountInstruction,
   parseOpenMarketInstruction,
-  parsePauseStakingInstruction,
   parseResolveMarketInstruction,
-  parseResumeStakingInstruction,
   parseRevealStakeCallbackInstruction,
   parseRevealStakeCompDefInstruction,
   parseRevealStakeInstruction,
@@ -8773,11 +8766,9 @@ export {
   parseUnstakeInstruction,
   parseUpdatePlatformConfigInstruction,
   parseWithdrawRewardInstruction,
-  pauseStaking,
   randomComputationOffset,
   randomStateNonce,
   resolveMarket,
-  resumeStaking,
   revealStake,
   setFeeClaimAuthority,
   setUpdateAuthority,