@bench.games/opportunity-markets 0.3.1 → 0.3.2

package/dist/index.cjs

@@ -68,11 +68,10 @@ __export(index_exports, {
   OPPORTUNITY_MARKET_ERROR__LOCKED: () => OPPORTUNITY_MARKET_ERROR__LOCKED,
   OPPORTUNITY_MARKET_ERROR__MARKET_ALREADY_OPEN: () => OPPORTUNITY_MARKET_ERROR__MARKET_ALREADY_OPEN,
   OPPORTUNITY_MARKET_ERROR__MARKET_NOT_OPEN: () => OPPORTUNITY_MARKET_ERROR__MARKET_NOT_OPEN,
-  OPPORTUNITY_MARKET_ERROR__MARKET_NOT_PAUSED: () => OPPORTUNITY_MARKET_ERROR__MARKET_NOT_PAUSED,
   OPPORTUNITY_MARKET_ERROR__MARKET_NOT_RESOLVED: () => OPPORTUNITY_MARKET_ERROR__MARKET_NOT_RESOLVED,
-  OPPORTUNITY_MARKET_ERROR__MARKET_PAUSED: () => OPPORTUNITY_MARKET_ERROR__MARKET_PAUSED,
   OPPORTUNITY_MARKET_ERROR__NOT_REVEALED: () => OPPORTUNITY_MARKET_ERROR__NOT_REVEALED,
   OPPORTUNITY_MARKET_ERROR__NO_FEES_TO_CLAIM: () => OPPORTUNITY_MARKET_ERROR__NO_FEES_TO_CLAIM,
+  OPPORTUNITY_MARKET_ERROR__NO_FINALIZED_WINNING_OPTION: () => OPPORTUNITY_MARKET_ERROR__NO_FINALIZED_WINNING_OPTION,
   OPPORTUNITY_MARKET_ERROR__NO_REWARD_TO_CLAIM: () => OPPORTUNITY_MARKET_ERROR__NO_REWARD_TO_CLAIM,
   OPPORTUNITY_MARKET_ERROR__NO_STAKE: () => OPPORTUNITY_MARKET_ERROR__NO_STAKE,
   OPPORTUNITY_MARKET_ERROR__OPTION_STILL_NEEDED: () => OPPORTUNITY_MARKET_ERROR__OPTION_STILL_NEEDED,
@@ -95,12 +94,10 @@ __export(index_exports, {
   OpportunityMarketAccount: () => OpportunityMarketAccount,
   OpportunityMarketInstruction: () => OpportunityMarketInstruction,
   Output: () => Output,
-  PAUSE_STAKING_DISCRIMINATOR: () => PAUSE_STAKING_DISCRIMINATOR,
   PLATFORM_CONFIG_DISCRIMINATOR: () => PLATFORM_CONFIG_DISCRIMINATOR,
   PLATFORM_CONFIG_SEED: () => PLATFORM_CONFIG_SEED,
   Parameter: () => Parameter,
   RESOLVE_MARKET_DISCRIMINATOR: () => RESOLVE_MARKET_DISCRIMINATOR,
-  RESUME_STAKING_DISCRIMINATOR: () => RESUME_STAKING_DISCRIMINATOR,
   REVEAL_STAKE_CALLBACK_DISCRIMINATOR: () => REVEAL_STAKE_CALLBACK_DISCRIMINATOR,
   REVEAL_STAKE_COMP_DEF_DISCRIMINATOR: () => REVEAL_STAKE_COMP_DEF_DISCRIMINATOR,
   REVEAL_STAKE_DISCRIMINATOR: () => REVEAL_STAKE_DISCRIMINATOR,
@@ -118,8 +115,9 @@ __export(index_exports, {
   WITHDRAW_REWARD_DISCRIMINATOR: () => WITHDRAW_REWARD_DISCRIMINATOR,
   addMarketOption: () => addMarketOption,
   addReward: () => addReward,
-  awaitBatchComputationFinalization: () => awaitBatchComputationFinalization,
   awaitComputationFinalization: () => awaitComputationFinalization,
+  awaitRevealStakeFinalization: () => awaitRevealStakeFinalization,
+  awaitStakeFinalization: () => awaitStakeFinalization,
   circuitSource: () => circuitSource,
   claimCreatorFees: () => claimCreatorFees,
   claimFees: () => claimFees,
@@ -370,11 +368,6 @@ __export(index_exports, {
   getParameterCodec: () => getParameterCodec,
   getParameterDecoder: () => getParameterDecoder,
   getParameterEncoder: () => getParameterEncoder,
-  getPauseStakingDiscriminatorBytes: () => getPauseStakingDiscriminatorBytes,
-  getPauseStakingInstruction: () => getPauseStakingInstruction,
-  getPauseStakingInstructionDataCodec: () => getPauseStakingInstructionDataCodec,
-  getPauseStakingInstructionDataDecoder: () => getPauseStakingInstructionDataDecoder,
-  getPauseStakingInstructionDataEncoder: () => getPauseStakingInstructionDataEncoder,
   getPlatformConfigAddress: () => getPlatformConfigAddress,
   getPlatformConfigCodec: () => getPlatformConfigCodec,
   getPlatformConfigDecoder: () => getPlatformConfigDecoder,
@@ -385,11 +378,6 @@ __export(index_exports, {
   getResolveMarketInstructionDataCodec: () => getResolveMarketInstructionDataCodec,
   getResolveMarketInstructionDataDecoder: () => getResolveMarketInstructionDataDecoder,
   getResolveMarketInstructionDataEncoder: () => getResolveMarketInstructionDataEncoder,
-  getResumeStakingDiscriminatorBytes: () => getResumeStakingDiscriminatorBytes,
-  getResumeStakingInstruction: () => getResumeStakingInstruction,
-  getResumeStakingInstructionDataCodec: () => getResumeStakingInstructionDataCodec,
-  getResumeStakingInstructionDataDecoder: () => getResumeStakingInstructionDataDecoder,
-  getResumeStakingInstructionDataEncoder: () => getResumeStakingInstructionDataEncoder,
   getRevealPeriodEndedEventCodec: () => getRevealPeriodEndedEventCodec,
   getRevealPeriodEndedEventDecoder: () => getRevealPeriodEndedEventDecoder,
   getRevealPeriodEndedEventEncoder: () => getRevealPeriodEndedEventEncoder,
@@ -476,12 +464,6 @@ __export(index_exports, {
   getStakedEventCodec: () => getStakedEventCodec,
   getStakedEventDecoder: () => getStakedEventDecoder,
   getStakedEventEncoder: () => getStakedEventEncoder,
-  getStakingPausedEventCodec: () => getStakingPausedEventCodec,
-  getStakingPausedEventDecoder: () => getStakingPausedEventDecoder,
-  getStakingPausedEventEncoder: () => getStakingPausedEventEncoder,
-  getStakingResumedEventCodec: () => getStakingResumedEventCodec,
-  getStakingResumedEventDecoder: () => getStakingResumedEventDecoder,
-  getStakingResumedEventEncoder: () => getStakingResumedEventEncoder,
   getStuckStakeClosedEventCodec: () => getStuckStakeClosedEventCodec,
   getStuckStakeClosedEventDecoder: () => getStuckStakeClosedEventDecoder,
   getStuckStakeClosedEventEncoder: () => getStuckStakeClosedEventEncoder,
@@ -539,9 +521,7 @@ __export(index_exports, {
   parseInitPlatformConfigInstruction: () => parseInitPlatformConfigInstruction,
   parseInitStakeAccountInstruction: () => parseInitStakeAccountInstruction,
   parseOpenMarketInstruction: () => parseOpenMarketInstruction,
-  parsePauseStakingInstruction: () => parsePauseStakingInstruction,
   parseResolveMarketInstruction: () => parseResolveMarketInstruction,
-  parseResumeStakingInstruction: () => parseResumeStakingInstruction,
   parseRevealStakeCallbackInstruction: () => parseRevealStakeCallbackInstruction,
   parseRevealStakeCompDefInstruction: () => parseRevealStakeCompDefInstruction,
   parseRevealStakeInstruction: () => parseRevealStakeInstruction,
@@ -554,11 +534,9 @@ __export(index_exports, {
   parseUnstakeInstruction: () => parseUnstakeInstruction,
   parseUpdatePlatformConfigInstruction: () => parseUpdatePlatformConfigInstruction,
   parseWithdrawRewardInstruction: () => parseWithdrawRewardInstruction,
-  pauseStaking: () => pauseStaking,
   randomComputationOffset: () => randomComputationOffset,
   randomStateNonce: () => randomStateNonce,
   resolveMarket: () => resolveMarket,
-  resumeStaking: () => resumeStaking,
   revealStake: () => revealStake,
   setFeeClaimAuthority: () => setFeeClaimAuthority,
   setUpdateAuthority: () => setUpdateAuthority,
@@ -712,7 +690,7 @@ async function fetchAllMaybeArciumSignerAccount(rpc, addresses, config) {
 }
 
 // src/generated/accounts/opportunityMarket.ts
-var import_kit52 = require("@solana/kit");
+var import_kit50 = require("@solana/kit");
 
 // src/generated/types/activation.ts
 var import_kit3 = require("@solana/kit");
@@ -1189,8 +1167,7 @@ function getMarketCreatedEventEncoder() {
     ["feeRates", getFeeRatesEncoder()],
     ["creatorFeeClaimer", (0, import_kit20.getAddressEncoder)()],
     ["marketResolutionDeadlineSeconds", (0, import_kit20.getU64Encoder)()],
-    ["minRevealPeriodSeconds", (0, import_kit20.getU64Encoder)()],
-    ["maxRevealPeriodSeconds", (0, import_kit20.getU64Encoder)()],
+    ["revealPeriodSeconds", (0, import_kit20.getU64Encoder)()],
     ["timestamp", (0, import_kit20.getI64Encoder)()]
   ]);
 }
@@ -1210,8 +1187,7 @@ function getMarketCreatedEventDecoder() {
     ["feeRates", getFeeRatesDecoder()],
     ["creatorFeeClaimer", (0, import_kit20.getAddressDecoder)()],
     ["marketResolutionDeadlineSeconds", (0, import_kit20.getU64Decoder)()],
-    ["minRevealPeriodSeconds", (0, import_kit20.getU64Decoder)()],
-    ["maxRevealPeriodSeconds", (0, import_kit20.getU64Decoder)()],
+    ["revealPeriodSeconds", (0, import_kit20.getU64Decoder)()],
     ["timestamp", (0, import_kit20.getI64Decoder)()]
   ]);
 }
@@ -1915,194 +1891,152 @@ function getStakeRevealedEventCodec() {
   );
 }
 
-// src/generated/types/stakingPausedEvent.ts
+// src/generated/types/stuckStakeClosedEvent.ts
 var import_kit44 = require("@solana/kit");
-function getStakingPausedEventEncoder() {
+function getStuckStakeClosedEventEncoder() {
   return (0, import_kit44.getStructEncoder)([
+    ["owner", (0, import_kit44.getAddressEncoder)()],
     ["market", (0, import_kit44.getAddressEncoder)()],
+    ["stakeAccount", (0, import_kit44.getAddressEncoder)()],
+    ["stakeAccountId", (0, import_kit44.getU32Encoder)()],
+    ["refundedAmount", (0, import_kit44.getU64Encoder)()],
+    ["refundedPlatformFee", (0, import_kit44.getU64Encoder)()],
+    ["refundedRewardPoolFee", (0, import_kit44.getU64Encoder)()],
+    ["refundedCreatorFee", (0, import_kit44.getU64Encoder)()],
     ["timestamp", (0, import_kit44.getI64Encoder)()]
   ]);
 }
-function getStakingPausedEventDecoder() {
+function getStuckStakeClosedEventDecoder() {
   return (0, import_kit44.getStructDecoder)([
+    ["owner", (0, import_kit44.getAddressDecoder)()],
     ["market", (0, import_kit44.getAddressDecoder)()],
+    ["stakeAccount", (0, import_kit44.getAddressDecoder)()],
+    ["stakeAccountId", (0, import_kit44.getU32Decoder)()],
+    ["refundedAmount", (0, import_kit44.getU64Decoder)()],
+    ["refundedPlatformFee", (0, import_kit44.getU64Decoder)()],
+    ["refundedRewardPoolFee", (0, import_kit44.getU64Decoder)()],
+    ["refundedCreatorFee", (0, import_kit44.getU64Decoder)()],
     ["timestamp", (0, import_kit44.getI64Decoder)()]
   ]);
 }
-function getStakingPausedEventCodec() {
+function getStuckStakeClosedEventCodec() {
   return (0, import_kit44.combineCodec)(
-    getStakingPausedEventEncoder(),
-    getStakingPausedEventDecoder()
+    getStuckStakeClosedEventEncoder(),
+    getStuckStakeClosedEventDecoder()
   );
 }
 
-// src/generated/types/stakingResumedEvent.ts
+// src/generated/types/timestamp.ts
 var import_kit45 = require("@solana/kit");
-function getStakingResumedEventEncoder() {
-  return (0, import_kit45.getStructEncoder)([
-    ["market", (0, import_kit45.getAddressEncoder)()],
-    ["timestamp", (0, import_kit45.getI64Encoder)()]
-  ]);
+function getTimestampEncoder() {
+  return (0, import_kit45.getStructEncoder)([["timestamp", (0, import_kit45.getU64Encoder)()]]);
 }
-function getStakingResumedEventDecoder() {
-  return (0, import_kit45.getStructDecoder)([
-    ["market", (0, import_kit45.getAddressDecoder)()],
-    ["timestamp", (0, import_kit45.getI64Decoder)()]
-  ]);
+function getTimestampDecoder() {
+  return (0, import_kit45.getStructDecoder)([["timestamp", (0, import_kit45.getU64Decoder)()]]);
 }
-function getStakingResumedEventCodec() {
-  return (0, import_kit45.combineCodec)(
-    getStakingResumedEventEncoder(),
-    getStakingResumedEventDecoder()
-  );
+function getTimestampCodec() {
+  return (0, import_kit45.combineCodec)(getTimestampEncoder(), getTimestampDecoder());
 }
 
-// src/generated/types/stuckStakeClosedEvent.ts
+// src/generated/types/unstakedEvent.ts
 var import_kit46 = require("@solana/kit");
-function getStuckStakeClosedEventEncoder() {
+function getUnstakedEventEncoder() {
   return (0, import_kit46.getStructEncoder)([
     ["owner", (0, import_kit46.getAddressEncoder)()],
     ["market", (0, import_kit46.getAddressEncoder)()],
     ["stakeAccount", (0, import_kit46.getAddressEncoder)()],
     ["stakeAccountId", (0, import_kit46.getU32Encoder)()],
-    ["refundedAmount", (0, import_kit46.getU64Encoder)()],
-    ["refundedPlatformFee", (0, import_kit46.getU64Encoder)()],
-    ["refundedRewardPoolFee", (0, import_kit46.getU64Encoder)()],
-    ["refundedCreatorFee", (0, import_kit46.getU64Encoder)()],
+    ["amount", (0, import_kit46.getU64Encoder)()],
     ["timestamp", (0, import_kit46.getI64Encoder)()]
   ]);
 }
-function getStuckStakeClosedEventDecoder() {
+function getUnstakedEventDecoder() {
   return (0, import_kit46.getStructDecoder)([
     ["owner", (0, import_kit46.getAddressDecoder)()],
     ["market", (0, import_kit46.getAddressDecoder)()],
     ["stakeAccount", (0, import_kit46.getAddressDecoder)()],
     ["stakeAccountId", (0, import_kit46.getU32Decoder)()],
-    ["refundedAmount", (0, import_kit46.getU64Decoder)()],
-    ["refundedPlatformFee", (0, import_kit46.getU64Decoder)()],
-    ["refundedRewardPoolFee", (0, import_kit46.getU64Decoder)()],
-    ["refundedCreatorFee", (0, import_kit46.getU64Decoder)()],
+    ["amount", (0, import_kit46.getU64Decoder)()],
     ["timestamp", (0, import_kit46.getI64Decoder)()]
   ]);
 }
-function getStuckStakeClosedEventCodec() {
-  return (0, import_kit46.combineCodec)(
-    getStuckStakeClosedEventEncoder(),
-    getStuckStakeClosedEventDecoder()
-  );
-}
-
-// src/generated/types/timestamp.ts
-var import_kit47 = require("@solana/kit");
-function getTimestampEncoder() {
-  return (0, import_kit47.getStructEncoder)([["timestamp", (0, import_kit47.getU64Encoder)()]]);
-}
-function getTimestampDecoder() {
-  return (0, import_kit47.getStructDecoder)([["timestamp", (0, import_kit47.getU64Decoder)()]]);
-}
-function getTimestampCodec() {
-  return (0, import_kit47.combineCodec)(getTimestampEncoder(), getTimestampDecoder());
-}
-
-// src/generated/types/unstakedEvent.ts
-var import_kit48 = require("@solana/kit");
-function getUnstakedEventEncoder() {
-  return (0, import_kit48.getStructEncoder)([
-    ["owner", (0, import_kit48.getAddressEncoder)()],
-    ["market", (0, import_kit48.getAddressEncoder)()],
-    ["stakeAccount", (0, import_kit48.getAddressEncoder)()],
-    ["stakeAccountId", (0, import_kit48.getU32Encoder)()],
-    ["amount", (0, import_kit48.getU64Encoder)()],
-    ["timestamp", (0, import_kit48.getI64Encoder)()]
-  ]);
-}
-function getUnstakedEventDecoder() {
-  return (0, import_kit48.getStructDecoder)([
-    ["owner", (0, import_kit48.getAddressDecoder)()],
-    ["market", (0, import_kit48.getAddressDecoder)()],
-    ["stakeAccount", (0, import_kit48.getAddressDecoder)()],
-    ["stakeAccountId", (0, import_kit48.getU32Decoder)()],
-    ["amount", (0, import_kit48.getU64Decoder)()],
-    ["timestamp", (0, import_kit48.getI64Decoder)()]
-  ]);
-}
 function getUnstakedEventCodec() {
-  return (0, import_kit48.combineCodec)(getUnstakedEventEncoder(), getUnstakedEventDecoder());
+  return (0, import_kit46.combineCodec)(getUnstakedEventEncoder(), getUnstakedEventDecoder());
 }
 
 // src/generated/types/updateAuthorityChangedEvent.ts
-var import_kit49 = require("@solana/kit");
+var import_kit47 = require("@solana/kit");
 function getUpdateAuthorityChangedEventEncoder() {
-  return (0, import_kit49.getStructEncoder)([
-    ["platformConfig", (0, import_kit49.getAddressEncoder)()],
-    ["oldValue", (0, import_kit49.getAddressEncoder)()],
-    ["newValue", (0, import_kit49.getAddressEncoder)()],
-    ["timestamp", (0, import_kit49.getI64Encoder)()]
+  return (0, import_kit47.getStructEncoder)([
+    ["platformConfig", (0, import_kit47.getAddressEncoder)()],
+    ["oldValue", (0, import_kit47.getAddressEncoder)()],
+    ["newValue", (0, import_kit47.getAddressEncoder)()],
+    ["timestamp", (0, import_kit47.getI64Encoder)()]
   ]);
 }
 function getUpdateAuthorityChangedEventDecoder() {
-  return (0, import_kit49.getStructDecoder)([
-    ["platformConfig", (0, import_kit49.getAddressDecoder)()],
-    ["oldValue", (0, import_kit49.getAddressDecoder)()],
-    ["newValue", (0, import_kit49.getAddressDecoder)()],
-    ["timestamp", (0, import_kit49.getI64Decoder)()]
+  return (0, import_kit47.getStructDecoder)([
+    ["platformConfig", (0, import_kit47.getAddressDecoder)()],
+    ["oldValue", (0, import_kit47.getAddressDecoder)()],
+    ["newValue", (0, import_kit47.getAddressDecoder)()],
+    ["timestamp", (0, import_kit47.getI64Decoder)()]
   ]);
 }
 function getUpdateAuthorityChangedEventCodec() {
-  return (0, import_kit49.combineCodec)(
+  return (0, import_kit47.combineCodec)(
     getUpdateAuthorityChangedEventEncoder(),
     getUpdateAuthorityChangedEventDecoder()
   );
 }
 
 // src/generated/types/utilityPubkeys.ts
-var import_kit50 = require("@solana/kit");
+var import_kit48 = require("@solana/kit");
 function getUtilityPubkeysEncoder() {
-  return (0, import_kit50.getStructEncoder)([
-    ["x25519Pubkey", (0, import_kit50.getArrayEncoder)((0, import_kit50.getU8Encoder)(), { size: 32 })],
-    ["ed25519VerifyingKey", (0, import_kit50.getArrayEncoder)((0, import_kit50.getU8Encoder)(), { size: 32 })],
-    ["elgamalPubkey", (0, import_kit50.getArrayEncoder)((0, import_kit50.getU8Encoder)(), { size: 32 })],
-    ["pubkeyValidityProof", (0, import_kit50.getArrayEncoder)((0, import_kit50.getU8Encoder)(), { size: 64 })]
+  return (0, import_kit48.getStructEncoder)([
+    ["x25519Pubkey", (0, import_kit48.getArrayEncoder)((0, import_kit48.getU8Encoder)(), { size: 32 })],
+    ["ed25519VerifyingKey", (0, import_kit48.getArrayEncoder)((0, import_kit48.getU8Encoder)(), { size: 32 })],
+    ["elgamalPubkey", (0, import_kit48.getArrayEncoder)((0, import_kit48.getU8Encoder)(), { size: 32 })],
+    ["pubkeyValidityProof", (0, import_kit48.getArrayEncoder)((0, import_kit48.getU8Encoder)(), { size: 64 })]
   ]);
 }
 function getUtilityPubkeysDecoder() {
-  return (0, import_kit50.getStructDecoder)([
-    ["x25519Pubkey", (0, import_kit50.getArrayDecoder)((0, import_kit50.getU8Decoder)(), { size: 32 })],
-    ["ed25519VerifyingKey", (0, import_kit50.getArrayDecoder)((0, import_kit50.getU8Decoder)(), { size: 32 })],
-    ["elgamalPubkey", (0, import_kit50.getArrayDecoder)((0, import_kit50.getU8Decoder)(), { size: 32 })],
-    ["pubkeyValidityProof", (0, import_kit50.getArrayDecoder)((0, import_kit50.getU8Decoder)(), { size: 64 })]
+  return (0, import_kit48.getStructDecoder)([
+    ["x25519Pubkey", (0, import_kit48.getArrayDecoder)((0, import_kit48.getU8Decoder)(), { size: 32 })],
+    ["ed25519VerifyingKey", (0, import_kit48.getArrayDecoder)((0, import_kit48.getU8Decoder)(), { size: 32 })],
+    ["elgamalPubkey", (0, import_kit48.getArrayDecoder)((0, import_kit48.getU8Decoder)(), { size: 32 })],
+    ["pubkeyValidityProof", (0, import_kit48.getArrayDecoder)((0, import_kit48.getU8Decoder)(), { size: 64 })]
   ]);
 }
 function getUtilityPubkeysCodec() {
-  return (0, import_kit50.combineCodec)(getUtilityPubkeysEncoder(), getUtilityPubkeysDecoder());
+  return (0, import_kit48.combineCodec)(getUtilityPubkeysEncoder(), getUtilityPubkeysDecoder());
 }
 
 // src/generated/types/winningOptionSetEvent.ts
-var import_kit51 = require("@solana/kit");
+var import_kit49 = require("@solana/kit");
 function getWinningOptionSetEventEncoder() {
-  return (0, import_kit51.getStructEncoder)([
-    ["market", (0, import_kit51.getAddressEncoder)()],
-    ["marketAuthority", (0, import_kit51.getAddressEncoder)()],
-    ["option", (0, import_kit51.getAddressEncoder)()],
-    ["optionId", (0, import_kit51.getU64Encoder)()],
-    ["rewardBp", (0, import_kit51.getU16Encoder)()],
-    ["winningOptionAllocation", (0, import_kit51.getU16Encoder)()],
-    ["timestamp", (0, import_kit51.getI64Encoder)()]
+  return (0, import_kit49.getStructEncoder)([
+    ["market", (0, import_kit49.getAddressEncoder)()],
+    ["marketAuthority", (0, import_kit49.getAddressEncoder)()],
+    ["option", (0, import_kit49.getAddressEncoder)()],
+    ["optionId", (0, import_kit49.getU64Encoder)()],
+    ["rewardBp", (0, import_kit49.getU16Encoder)()],
+    ["winningOptionAllocation", (0, import_kit49.getU16Encoder)()],
+    ["timestamp", (0, import_kit49.getI64Encoder)()]
   ]);
 }
 function getWinningOptionSetEventDecoder() {
-  return (0, import_kit51.getStructDecoder)([
-    ["market", (0, import_kit51.getAddressDecoder)()],
-    ["marketAuthority", (0, import_kit51.getAddressDecoder)()],
-    ["option", (0, import_kit51.getAddressDecoder)()],
-    ["optionId", (0, import_kit51.getU64Decoder)()],
-    ["rewardBp", (0, import_kit51.getU16Decoder)()],
-    ["winningOptionAllocation", (0, import_kit51.getU16Decoder)()],
-    ["timestamp", (0, import_kit51.getI64Decoder)()]
+  return (0, import_kit49.getStructDecoder)([
+    ["market", (0, import_kit49.getAddressDecoder)()],
+    ["marketAuthority", (0, import_kit49.getAddressDecoder)()],
+    ["option", (0, import_kit49.getAddressDecoder)()],
+    ["optionId", (0, import_kit49.getU64Decoder)()],
+    ["rewardBp", (0, import_kit49.getU16Decoder)()],
+    ["winningOptionAllocation", (0, import_kit49.getU16Decoder)()],
+    ["timestamp", (0, import_kit49.getI64Decoder)()]
   ]);
 }
 function getWinningOptionSetEventCodec() {
-  return (0, import_kit51.combineCodec)(
+  return (0, import_kit49.combineCodec)(
     getWinningOptionSetEventEncoder(),
     getWinningOptionSetEventDecoder()
   );
@@ -2120,94 +2054,90 @@ var OPPORTUNITY_MARKET_DISCRIMINATOR = new Uint8Array([
   224
 ]);
 function getOpportunityMarketDiscriminatorBytes() {
-  return (0, import_kit52.fixEncoderSize)((0, import_kit52.getBytesEncoder)(), 8).encode(
+  return (0, import_kit50.fixEncoderSize)((0, import_kit50.getBytesEncoder)(), 8).encode(
     OPPORTUNITY_MARKET_DISCRIMINATOR
   );
 }
 function getOpportunityMarketEncoder() {
-  return (0, import_kit52.transformEncoder)(
-    (0, import_kit52.getStructEncoder)([
-      ["discriminator", (0, import_kit52.fixEncoderSize)((0, import_kit52.getBytesEncoder)(), 8)],
-      ["bump", (0, import_kit52.getU8Encoder)()],
-      ["creator", (0, import_kit52.getAddressEncoder)()],
-      ["index", (0, import_kit52.getU64Encoder)()],
-      ["totalOptions", (0, import_kit52.getU64Encoder)()],
-      ["platform", (0, import_kit52.getAddressEncoder)()],
-      ["stakeEndTimestamp", (0, import_kit52.getOptionEncoder)((0, import_kit52.getU64Encoder)())],
-      ["resolvedAtTimestamp", (0, import_kit52.getOptionEncoder)((0, import_kit52.getU64Encoder)())],
-      ["winningOptionAllocation", (0, import_kit52.getU16Encoder)()],
-      ["rewardAmount", (0, import_kit52.getU64Encoder)()],
-      ["marketAuthority", (0, import_kit52.getAddressEncoder)()],
-      ["revealPeriodAuthority", (0, import_kit52.getAddressEncoder)()],
-      ["mint", (0, import_kit52.getAddressEncoder)()],
-      ["earlinessCutoffSeconds", (0, import_kit52.getU64Encoder)()],
-      ["earlinessMultiplier", (0, import_kit52.getU16Encoder)()],
-      ["allowUnstakingEarly", (0, import_kit52.getBooleanEncoder)()],
-      ["authorizedReaderPubkey", (0, import_kit52.getArrayEncoder)((0, import_kit52.getU8Encoder)(), { size: 32 })],
-      ["stakingPaused", (0, import_kit52.getBooleanEncoder)()],
+  return (0, import_kit50.transformEncoder)(
+    (0, import_kit50.getStructEncoder)([
+      ["discriminator", (0, import_kit50.fixEncoderSize)((0, import_kit50.getBytesEncoder)(), 8)],
+      ["bump", (0, import_kit50.getU8Encoder)()],
+      ["creator", (0, import_kit50.getAddressEncoder)()],
+      ["index", (0, import_kit50.getU64Encoder)()],
+      ["totalOptions", (0, import_kit50.getU64Encoder)()],
+      ["platform", (0, import_kit50.getAddressEncoder)()],
+      ["stakeEndTimestamp", (0, import_kit50.getOptionEncoder)((0, import_kit50.getU64Encoder)())],
+      ["resolvedAtTimestamp", (0, import_kit50.getOptionEncoder)((0, import_kit50.getU64Encoder)())],
+      ["winningOptionAllocation", (0, import_kit50.getU16Encoder)()],
+      ["winningOptionActiveBp", (0, import_kit50.getU16Encoder)()],
+      ["rewardAmount", (0, import_kit50.getU64Encoder)()],
+      ["marketAuthority", (0, import_kit50.getAddressEncoder)()],
+      ["mint", (0, import_kit50.getAddressEncoder)()],
+      ["earlinessCutoffSeconds", (0, import_kit50.getU64Encoder)()],
+      ["earlinessMultiplier", (0, import_kit50.getU16Encoder)()],
+      ["allowUnstakingEarly", (0, import_kit50.getBooleanEncoder)()],
+      ["authorizedReaderPubkey", (0, import_kit50.getArrayEncoder)((0, import_kit50.getU8Encoder)(), { size: 32 })],
       ["feeRates", getFeeRatesEncoder()],
-      ["collectedPlatformFees", (0, import_kit52.getU64Encoder)()],
-      ["collectedCreatorFees", (0, import_kit52.getU64Encoder)()],
-      ["creatorFeeClaimer", (0, import_kit52.getAddressEncoder)()],
-      ["marketResolutionDeadlineSeconds", (0, import_kit52.getU64Encoder)()],
-      ["minRevealPeriodSeconds", (0, import_kit52.getU64Encoder)()],
-      ["maxRevealPeriodSeconds", (0, import_kit52.getU64Encoder)()],
-      ["revealEnded", (0, import_kit52.getBooleanEncoder)()],
-      ["minStakeAmount", (0, import_kit52.getU64Encoder)()]
+      ["collectedPlatformFees", (0, import_kit50.getU64Encoder)()],
+      ["collectedCreatorFees", (0, import_kit50.getU64Encoder)()],
+      ["creatorFeeClaimer", (0, import_kit50.getAddressEncoder)()],
+      ["marketResolutionDeadlineSeconds", (0, import_kit50.getU64Encoder)()],
+      ["revealPeriodSeconds", (0, import_kit50.getU64Encoder)()],
+      ["revealEnded", (0, import_kit50.getBooleanEncoder)()],
+      ["minStakeAmount", (0, import_kit50.getU64Encoder)()]
     ]),
     (value) => ({ ...value, discriminator: OPPORTUNITY_MARKET_DISCRIMINATOR })
   );
 }
 function getOpportunityMarketDecoder() {
-  return (0, import_kit52.getStructDecoder)([
-    ["discriminator", (0, import_kit52.fixDecoderSize)((0, import_kit52.getBytesDecoder)(), 8)],
-    ["bump", (0, import_kit52.getU8Decoder)()],
-    ["creator", (0, import_kit52.getAddressDecoder)()],
-    ["index", (0, import_kit52.getU64Decoder)()],
-    ["totalOptions", (0, import_kit52.getU64Decoder)()],
-    ["platform", (0, import_kit52.getAddressDecoder)()],
-    ["stakeEndTimestamp", (0, import_kit52.getOptionDecoder)((0, import_kit52.getU64Decoder)())],
-    ["resolvedAtTimestamp", (0, import_kit52.getOptionDecoder)((0, import_kit52.getU64Decoder)())],
-    ["winningOptionAllocation", (0, import_kit52.getU16Decoder)()],
-    ["rewardAmount", (0, import_kit52.getU64Decoder)()],
-    ["marketAuthority", (0, import_kit52.getAddressDecoder)()],
-    ["revealPeriodAuthority", (0, import_kit52.getAddressDecoder)()],
-    ["mint", (0, import_kit52.getAddressDecoder)()],
-    ["earlinessCutoffSeconds", (0, import_kit52.getU64Decoder)()],
-    ["earlinessMultiplier", (0, import_kit52.getU16Decoder)()],
-    ["allowUnstakingEarly", (0, import_kit52.getBooleanDecoder)()],
-    ["authorizedReaderPubkey", (0, import_kit52.getArrayDecoder)((0, import_kit52.getU8Decoder)(), { size: 32 })],
-    ["stakingPaused", (0, import_kit52.getBooleanDecoder)()],
+  return (0, import_kit50.getStructDecoder)([
+    ["discriminator", (0, import_kit50.fixDecoderSize)((0, import_kit50.getBytesDecoder)(), 8)],
+    ["bump", (0, import_kit50.getU8Decoder)()],
+    ["creator", (0, import_kit50.getAddressDecoder)()],
+    ["index", (0, import_kit50.getU64Decoder)()],
+    ["totalOptions", (0, import_kit50.getU64Decoder)()],
+    ["platform", (0, import_kit50.getAddressDecoder)()],
+    ["stakeEndTimestamp", (0, import_kit50.getOptionDecoder)((0, import_kit50.getU64Decoder)())],
+    ["resolvedAtTimestamp", (0, import_kit50.getOptionDecoder)((0, import_kit50.getU64Decoder)())],
+    ["winningOptionAllocation", (0, import_kit50.getU16Decoder)()],
+    ["winningOptionActiveBp", (0, import_kit50.getU16Decoder)()],
+    ["rewardAmount", (0, import_kit50.getU64Decoder)()],
+    ["marketAuthority", (0, import_kit50.getAddressDecoder)()],
+    ["mint", (0, import_kit50.getAddressDecoder)()],
+    ["earlinessCutoffSeconds", (0, import_kit50.getU64Decoder)()],
+    ["earlinessMultiplier", (0, import_kit50.getU16Decoder)()],
+    ["allowUnstakingEarly", (0, import_kit50.getBooleanDecoder)()],
+    ["authorizedReaderPubkey", (0, import_kit50.getArrayDecoder)((0, import_kit50.getU8Decoder)(), { size: 32 })],
     ["feeRates", getFeeRatesDecoder()],
-    ["collectedPlatformFees", (0, import_kit52.getU64Decoder)()],
-    ["collectedCreatorFees", (0, import_kit52.getU64Decoder)()],
-    ["creatorFeeClaimer", (0, import_kit52.getAddressDecoder)()],
-    ["marketResolutionDeadlineSeconds", (0, import_kit52.getU64Decoder)()],
-    ["minRevealPeriodSeconds", (0, import_kit52.getU64Decoder)()],
-    ["maxRevealPeriodSeconds", (0, import_kit52.getU64Decoder)()],
-    ["revealEnded", (0, import_kit52.getBooleanDecoder)()],
-    ["minStakeAmount", (0, import_kit52.getU64Decoder)()]
+    ["collectedPlatformFees", (0, import_kit50.getU64Decoder)()],
+    ["collectedCreatorFees", (0, import_kit50.getU64Decoder)()],
+    ["creatorFeeClaimer", (0, import_kit50.getAddressDecoder)()],
+    ["marketResolutionDeadlineSeconds", (0, import_kit50.getU64Decoder)()],
+    ["revealPeriodSeconds", (0, import_kit50.getU64Decoder)()],
+    ["revealEnded", (0, import_kit50.getBooleanDecoder)()],
+    ["minStakeAmount", (0, import_kit50.getU64Decoder)()]
   ]);
 }
 function getOpportunityMarketCodec() {
-  return (0, import_kit52.combineCodec)(
+  return (0, import_kit50.combineCodec)(
     getOpportunityMarketEncoder(),
     getOpportunityMarketDecoder()
   );
 }
 function decodeOpportunityMarket(encodedAccount) {
-  return (0, import_kit52.decodeAccount)(
+  return (0, import_kit50.decodeAccount)(
     encodedAccount,
     getOpportunityMarketDecoder()
   );
 }
 async function fetchOpportunityMarket(rpc, address3, config) {
   const maybeAccount = await fetchMaybeOpportunityMarket(rpc, address3, config);
-  (0, import_kit52.assertAccountExists)(maybeAccount);
+  (0, import_kit50.assertAccountExists)(maybeAccount);
   return maybeAccount;
 }
 async function fetchMaybeOpportunityMarket(rpc, address3, config) {
-  const maybeAccount = await (0, import_kit52.fetchEncodedAccount)(rpc, address3, config);
+  const maybeAccount = await (0, import_kit50.fetchEncodedAccount)(rpc, address3, config);
   return decodeOpportunityMarket(maybeAccount);
 }
 async function fetchAllOpportunityMarket(rpc, addresses, config) {
@@ -2216,18 +2146,18 @@ async function fetchAllOpportunityMarket(rpc, addresses, config) {
     addresses,
     config
   );
-  (0, import_kit52.assertAccountsExist)(maybeAccounts);
+  (0, import_kit50.assertAccountsExist)(maybeAccounts);
   return maybeAccounts;
 }
 async function fetchAllMaybeOpportunityMarket(rpc, addresses, config) {
-  const maybeAccounts = await (0, import_kit52.fetchEncodedAccounts)(rpc, addresses, config);
+  const maybeAccounts = await (0, import_kit50.fetchEncodedAccounts)(rpc, addresses, config);
   return maybeAccounts.map(
     (maybeAccount) => decodeOpportunityMarket(maybeAccount)
   );
 }
 
 // src/generated/accounts/opportunityMarketOption.ts
-var import_kit53 = require("@solana/kit");
+var import_kit51 = require("@solana/kit");
 var OPPORTUNITY_MARKET_OPTION_DISCRIMINATOR = new Uint8Array([
   220,
   236,
@@ -2239,21 +2169,22 @@ var OPPORTUNITY_MARKET_OPTION_DISCRIMINATOR = new Uint8Array([
   64
 ]);
 function getOpportunityMarketOptionDiscriminatorBytes() {
-  return (0, import_kit53.fixEncoderSize)((0, import_kit53.getBytesEncoder)(), 8).encode(
+  return (0, import_kit51.fixEncoderSize)((0, import_kit51.getBytesEncoder)(), 8).encode(
     OPPORTUNITY_MARKET_OPTION_DISCRIMINATOR
   );
 }
 function getOpportunityMarketOptionEncoder() {
-  return (0, import_kit53.transformEncoder)(
-    (0, import_kit53.getStructEncoder)([
-      ["discriminator", (0, import_kit53.fixEncoderSize)((0, import_kit53.getBytesEncoder)(), 8)],
-      ["bump", (0, import_kit53.getU8Encoder)()],
-      ["id", (0, import_kit53.getU64Encoder)()],
-      ["creator", (0, import_kit53.getAddressEncoder)()],
-      ["createdAt", (0, import_kit53.getU64Encoder)()],
-      ["totalStaked", (0, import_kit53.getU64Encoder)()],
-      ["totalScore", (0, import_kit53.getU128Encoder)()],
-      ["rewardBp", (0, import_kit53.getOptionEncoder)((0, import_kit53.getU16Encoder)())]
+  return (0, import_kit51.transformEncoder)(
+    (0, import_kit51.getStructEncoder)([
+      ["discriminator", (0, import_kit51.fixEncoderSize)((0, import_kit51.getBytesEncoder)(), 8)],
+      ["bump", (0, import_kit51.getU8Encoder)()],
+      ["id", (0, import_kit51.getU64Encoder)()],
+      ["creator", (0, import_kit51.getAddressEncoder)()],
+      ["createdAt", (0, import_kit51.getU64Encoder)()],
+      ["totalStaked", (0, import_kit51.getU64Encoder)()],
+      ["totalScore", (0, import_kit51.getU128Encoder)()],
+      ["rewardBp", (0, import_kit51.getU16Encoder)()],
+      ["includedInActiveBp", (0, import_kit51.getBooleanEncoder)()]
     ]),
     (value) => ({
       ...value,
@@ -2262,25 +2193,26 @@ function getOpportunityMarketOptionEncoder() {
   );
 }
 function getOpportunityMarketOptionDecoder() {
-  return (0, import_kit53.getStructDecoder)([
-    ["discriminator", (0, import_kit53.fixDecoderSize)((0, import_kit53.getBytesDecoder)(), 8)],
-    ["bump", (0, import_kit53.getU8Decoder)()],
-    ["id", (0, import_kit53.getU64Decoder)()],
-    ["creator", (0, import_kit53.getAddressDecoder)()],
-    ["createdAt", (0, import_kit53.getU64Decoder)()],
-    ["totalStaked", (0, import_kit53.getU64Decoder)()],
-    ["totalScore", (0, import_kit53.getU128Decoder)()],
-    ["rewardBp", (0, import_kit53.getOptionDecoder)((0, import_kit53.getU16Decoder)())]
+  return (0, import_kit51.getStructDecoder)([
+    ["discriminator", (0, import_kit51.fixDecoderSize)((0, import_kit51.getBytesDecoder)(), 8)],
+    ["bump", (0, import_kit51.getU8Decoder)()],
+    ["id", (0, import_kit51.getU64Decoder)()],
+    ["creator", (0, import_kit51.getAddressDecoder)()],
+    ["createdAt", (0, import_kit51.getU64Decoder)()],
+    ["totalStaked", (0, import_kit51.getU64Decoder)()],
+    ["totalScore", (0, import_kit51.getU128Decoder)()],
+    ["rewardBp", (0, import_kit51.getU16Decoder)()],
+    ["includedInActiveBp", (0, import_kit51.getBooleanDecoder)()]
   ]);
 }
 function getOpportunityMarketOptionCodec() {
-  return (0, import_kit53.combineCodec)(
+  return (0, import_kit51.combineCodec)(
     getOpportunityMarketOptionEncoder(),
     getOpportunityMarketOptionDecoder()
   );
 }
 function decodeOpportunityMarketOption(encodedAccount) {
-  return (0, import_kit53.decodeAccount)(
+  return (0, import_kit51.decodeAccount)(
     encodedAccount,
     getOpportunityMarketOptionDecoder()
   );
@@ -2291,11 +2223,11 @@ async function fetchOpportunityMarketOption(rpc, address3, config) {
     address3,
     config
   );
-  (0, import_kit53.assertAccountExists)(maybeAccount);
+  (0, import_kit51.assertAccountExists)(maybeAccount);
   return maybeAccount;
 }
 async function fetchMaybeOpportunityMarketOption(rpc, address3, config) {
-  const maybeAccount = await (0, import_kit53.fetchEncodedAccount)(rpc, address3, config);
+  const maybeAccount = await (0, import_kit51.fetchEncodedAccount)(rpc, address3, config);
   return decodeOpportunityMarketOption(maybeAccount);
 }
 async function fetchAllOpportunityMarketOption(rpc, addresses, config) {
@@ -2304,18 +2236,18 @@ async function fetchAllOpportunityMarketOption(rpc, addresses, config) {
     addresses,
     config
   );
-  (0, import_kit53.assertAccountsExist)(maybeAccounts);
+  (0, import_kit51.assertAccountsExist)(maybeAccounts);
   return maybeAccounts;
 }
 async function fetchAllMaybeOpportunityMarketOption(rpc, addresses, config) {
-  const maybeAccounts = await (0, import_kit53.fetchEncodedAccounts)(rpc, addresses, config);
+  const maybeAccounts = await (0, import_kit51.fetchEncodedAccounts)(rpc, addresses, config);
   return maybeAccounts.map(
     (maybeAccount) => decodeOpportunityMarketOption(maybeAccount)
   );
 }
 
 // src/generated/accounts/opportunityMarketSponsor.ts
-var import_kit54 = require("@solana/kit");
+var import_kit52 = require("@solana/kit");
 var OPPORTUNITY_MARKET_SPONSOR_DISCRIMINATOR = new Uint8Array([
   207,
   139,
@@ -2327,19 +2259,19 @@ var OPPORTUNITY_MARKET_SPONSOR_DISCRIMINATOR = new Uint8Array([
   192
 ]);
 function getOpportunityMarketSponsorDiscriminatorBytes() {
-  return (0, import_kit54.fixEncoderSize)((0, import_kit54.getBytesEncoder)(), 8).encode(
+  return (0, import_kit52.fixEncoderSize)((0, import_kit52.getBytesEncoder)(), 8).encode(
     OPPORTUNITY_MARKET_SPONSOR_DISCRIMINATOR
   );
 }
 function getOpportunityMarketSponsorEncoder() {
-  return (0, import_kit54.transformEncoder)(
-    (0, import_kit54.getStructEncoder)([
-      ["discriminator", (0, import_kit54.fixEncoderSize)((0, import_kit54.getBytesEncoder)(), 8)],
-      ["bump", (0, import_kit54.getU8Encoder)()],
-      ["sponsor", (0, import_kit54.getAddressEncoder)()],
-      ["market", (0, import_kit54.getAddressEncoder)()],
-      ["rewardDeposited", (0, import_kit54.getU64Encoder)()],
-      ["rewardLocked", (0, import_kit54.getBooleanEncoder)()]
+  return (0, import_kit52.transformEncoder)(
+    (0, import_kit52.getStructEncoder)([
+      ["discriminator", (0, import_kit52.fixEncoderSize)((0, import_kit52.getBytesEncoder)(), 8)],
+      ["bump", (0, import_kit52.getU8Encoder)()],
+      ["sponsor", (0, import_kit52.getAddressEncoder)()],
+      ["market", (0, import_kit52.getAddressEncoder)()],
+      ["rewardDeposited", (0, import_kit52.getU64Encoder)()],
+      ["rewardLocked", (0, import_kit52.getBooleanEncoder)()]
     ]),
     (value) => ({
       ...value,
@@ -2348,23 +2280,23 @@ function getOpportunityMarketSponsorEncoder() {
   );
 }
 function getOpportunityMarketSponsorDecoder() {
-  return (0, import_kit54.getStructDecoder)([
-    ["discriminator", (0, import_kit54.fixDecoderSize)((0, import_kit54.getBytesDecoder)(), 8)],
-    ["bump", (0, import_kit54.getU8Decoder)()],
-    ["sponsor", (0, import_kit54.getAddressDecoder)()],
-    ["market", (0, import_kit54.getAddressDecoder)()],
-    ["rewardDeposited", (0, import_kit54.getU64Decoder)()],
-    ["rewardLocked", (0, import_kit54.getBooleanDecoder)()]
+  return (0, import_kit52.getStructDecoder)([
+    ["discriminator", (0, import_kit52.fixDecoderSize)((0, import_kit52.getBytesDecoder)(), 8)],
+    ["bump", (0, import_kit52.getU8Decoder)()],
+    ["sponsor", (0, import_kit52.getAddressDecoder)()],
+    ["market", (0, import_kit52.getAddressDecoder)()],
+    ["rewardDeposited", (0, import_kit52.getU64Decoder)()],
+    ["rewardLocked", (0, import_kit52.getBooleanDecoder)()]
   ]);
 }
 function getOpportunityMarketSponsorCodec() {
-  return (0, import_kit54.combineCodec)(
+  return (0, import_kit52.combineCodec)(
     getOpportunityMarketSponsorEncoder(),
     getOpportunityMarketSponsorDecoder()
   );
 }
 function decodeOpportunityMarketSponsor(encodedAccount) {
-  return (0, import_kit54.decodeAccount)(
+  return (0, import_kit52.decodeAccount)(
     encodedAccount,
     getOpportunityMarketSponsorDecoder()
   );
@@ -2375,11 +2307,11 @@ async function fetchOpportunityMarketSponsor(rpc, address3, config) {
     address3,
     config
   );
-  (0, import_kit54.assertAccountExists)(maybeAccount);
+  (0, import_kit52.assertAccountExists)(maybeAccount);
   return maybeAccount;
 }
 async function fetchMaybeOpportunityMarketSponsor(rpc, address3, config) {
-  const maybeAccount = await (0, import_kit54.fetchEncodedAccount)(rpc, address3, config);
+  const maybeAccount = await (0, import_kit52.fetchEncodedAccount)(rpc, address3, config);
   return decodeOpportunityMarketSponsor(maybeAccount);
 }
 async function fetchAllOpportunityMarketSponsor(rpc, addresses, config) {
@@ -2388,18 +2320,18 @@ async function fetchAllOpportunityMarketSponsor(rpc, addresses, config) {
     addresses,
     config
   );
-  (0, import_kit54.assertAccountsExist)(maybeAccounts);
+  (0, import_kit52.assertAccountsExist)(maybeAccounts);
   return maybeAccounts;
 }
 async function fetchAllMaybeOpportunityMarketSponsor(rpc, addresses, config) {
-  const maybeAccounts = await (0, import_kit54.fetchEncodedAccounts)(rpc, addresses, config);
+  const maybeAccounts = await (0, import_kit52.fetchEncodedAccounts)(rpc, addresses, config);
   return maybeAccounts.map(
     (maybeAccount) => decodeOpportunityMarketSponsor(maybeAccount)
   );
 }
 
 // src/generated/accounts/platformConfig.ts
-var import_kit55 = require("@solana/kit");
+var import_kit53 = require("@solana/kit");
 var PLATFORM_CONFIG_DISCRIMINATOR = new Uint8Array([
   160,
   78,
@@ -2411,57 +2343,57 @@ var PLATFORM_CONFIG_DISCRIMINATOR = new Uint8Array([
   160
 ]);
 function getPlatformConfigDiscriminatorBytes() {
-  return (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
+  return (0, import_kit53.fixEncoderSize)((0, import_kit53.getBytesEncoder)(), 8).encode(
     PLATFORM_CONFIG_DISCRIMINATOR
   );
 }
 function getPlatformConfigEncoder() {
-  return (0, import_kit55.transformEncoder)(
-    (0, import_kit55.getStructEncoder)([
-      ["discriminator", (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8)],
-      ["bump", (0, import_kit55.getU8Encoder)()],
-      ["name", (0, import_kit55.addEncoderSizePrefix)((0, import_kit55.getUtf8Encoder)(), (0, import_kit55.getU32Encoder)())],
-      ["updateAuthority", (0, import_kit55.getAddressEncoder)()],
-      ["feeClaimAuthority", (0, import_kit55.getAddressEncoder)()],
+  return (0, import_kit53.transformEncoder)(
+    (0, import_kit53.getStructEncoder)([
+      ["discriminator", (0, import_kit53.fixEncoderSize)((0, import_kit53.getBytesEncoder)(), 8)],
+      ["bump", (0, import_kit53.getU8Encoder)()],
+      ["name", (0, import_kit53.addEncoderSizePrefix)((0, import_kit53.getUtf8Encoder)(), (0, import_kit53.getU32Encoder)())],
+      ["updateAuthority", (0, import_kit53.getAddressEncoder)()],
+      ["feeClaimAuthority", (0, import_kit53.getAddressEncoder)()],
       ["feeRates", getFeeRatesEncoder()],
-      ["marketResolutionDeadlineSeconds", (0, import_kit55.getU64Encoder)()],
-      ["minTimeToStakeSeconds", (0, import_kit55.getU64Encoder)()],
-      ["minRevealPeriodSeconds", (0, import_kit55.getU64Encoder)()],
-      ["maxRevealPeriodSeconds", (0, import_kit55.getU64Encoder)()]
+      ["marketResolutionDeadlineSeconds", (0, import_kit53.getU64Encoder)()],
+      ["minTimeToStakeSeconds", (0, import_kit53.getU64Encoder)()],
+      ["revealAuthority", (0, import_kit53.getAddressEncoder)()],
+      ["revealPeriodSeconds", (0, import_kit53.getU64Encoder)()]
     ]),
     (value) => ({ ...value, discriminator: PLATFORM_CONFIG_DISCRIMINATOR })
   );
 }
 function getPlatformConfigDecoder() {
-  return (0, import_kit55.getStructDecoder)([
-    ["discriminator", (0, import_kit55.fixDecoderSize)((0, import_kit55.getBytesDecoder)(), 8)],
-    ["bump", (0, import_kit55.getU8Decoder)()],
-    ["name", (0, import_kit55.addDecoderSizePrefix)((0, import_kit55.getUtf8Decoder)(), (0, import_kit55.getU32Decoder)())],
-    ["updateAuthority", (0, import_kit55.getAddressDecoder)()],
-    ["feeClaimAuthority", (0, import_kit55.getAddressDecoder)()],
+  return (0, import_kit53.getStructDecoder)([
+    ["discriminator", (0, import_kit53.fixDecoderSize)((0, import_kit53.getBytesDecoder)(), 8)],
+    ["bump", (0, import_kit53.getU8Decoder)()],
+    ["name", (0, import_kit53.addDecoderSizePrefix)((0, import_kit53.getUtf8Decoder)(), (0, import_kit53.getU32Decoder)())],
+    ["updateAuthority", (0, import_kit53.getAddressDecoder)()],
+    ["feeClaimAuthority", (0, import_kit53.getAddressDecoder)()],
     ["feeRates", getFeeRatesDecoder()],
-    ["marketResolutionDeadlineSeconds", (0, import_kit55.getU64Decoder)()],
-    ["minTimeToStakeSeconds", (0, import_kit55.getU64Decoder)()],
-    ["minRevealPeriodSeconds", (0, import_kit55.getU64Decoder)()],
-    ["maxRevealPeriodSeconds", (0, import_kit55.getU64Decoder)()]
+    ["marketResolutionDeadlineSeconds", (0, import_kit53.getU64Decoder)()],
+    ["minTimeToStakeSeconds", (0, import_kit53.getU64Decoder)()],
+    ["revealAuthority", (0, import_kit53.getAddressDecoder)()],
+    ["revealPeriodSeconds", (0, import_kit53.getU64Decoder)()]
   ]);
 }
 function getPlatformConfigCodec() {
-  return (0, import_kit55.combineCodec)(getPlatformConfigEncoder(), getPlatformConfigDecoder());
+  return (0, import_kit53.combineCodec)(getPlatformConfigEncoder(), getPlatformConfigDecoder());
 }
 function decodePlatformConfig(encodedAccount) {
-  return (0, import_kit55.decodeAccount)(
+  return (0, import_kit53.decodeAccount)(
     encodedAccount,
     getPlatformConfigDecoder()
   );
 }
 async function fetchPlatformConfig(rpc, address3, config) {
   const maybeAccount = await fetchMaybePlatformConfig(rpc, address3, config);
-  (0, import_kit55.assertAccountExists)(maybeAccount);
+  (0, import_kit53.assertAccountExists)(maybeAccount);
   return maybeAccount;
 }
 async function fetchMaybePlatformConfig(rpc, address3, config) {
-  const maybeAccount = await (0, import_kit55.fetchEncodedAccount)(rpc, address3, config);
+  const maybeAccount = await (0, import_kit53.fetchEncodedAccount)(rpc, address3, config);
   return decodePlatformConfig(maybeAccount);
 }
 async function fetchAllPlatformConfig(rpc, addresses, config) {
@@ -2470,18 +2402,18 @@ async function fetchAllPlatformConfig(rpc, addresses, config) {
     addresses,
     config
   );
-  (0, import_kit55.assertAccountsExist)(maybeAccounts);
+  (0, import_kit53.assertAccountsExist)(maybeAccounts);
   return maybeAccounts;
 }
 async function fetchAllMaybePlatformConfig(rpc, addresses, config) {
-  const maybeAccounts = await (0, import_kit55.fetchEncodedAccounts)(rpc, addresses, config);
+  const maybeAccounts = await (0, import_kit53.fetchEncodedAccounts)(rpc, addresses, config);
   return maybeAccounts.map(
     (maybeAccount) => decodePlatformConfig(maybeAccount)
   );
 }
 
 // src/generated/accounts/stakeAccount.ts
-var import_kit56 = require("@solana/kit");
+var import_kit54 = require("@solana/kit");
 var STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   80,
   158,
@@ -2493,98 +2425,98 @@ var STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   255
 ]);
 function getStakeAccountDiscriminatorBytes() {
-  return (0, import_kit56.fixEncoderSize)((0, import_kit56.getBytesEncoder)(), 8).encode(
+  return (0, import_kit54.fixEncoderSize)((0, import_kit54.getBytesEncoder)(), 8).encode(
     STAKE_ACCOUNT_DISCRIMINATOR
   );
 }
 function getStakeAccountEncoder() {
-  return (0, import_kit56.transformEncoder)(
-    (0, import_kit56.getStructEncoder)([
-      ["discriminator", (0, import_kit56.fixEncoderSize)((0, import_kit56.getBytesEncoder)(), 8)],
-      ["encryptedOption", (0, import_kit56.getArrayEncoder)((0, import_kit56.getU8Encoder)(), { size: 32 })],
-      ["stateNonce", (0, import_kit56.getU128Encoder)()],
-      ["bump", (0, import_kit56.getU8Encoder)()],
-      ["owner", (0, import_kit56.getAddressEncoder)()],
-      ["market", (0, import_kit56.getAddressEncoder)()],
-      ["userPubkey", (0, import_kit56.getArrayEncoder)((0, import_kit56.getU8Encoder)(), { size: 32 })],
+  return (0, import_kit54.transformEncoder)(
+    (0, import_kit54.getStructEncoder)([
+      ["discriminator", (0, import_kit54.fixEncoderSize)((0, import_kit54.getBytesEncoder)(), 8)],
+      ["encryptedOption", (0, import_kit54.getArrayEncoder)((0, import_kit54.getU8Encoder)(), { size: 32 })],
+      ["stateNonce", (0, import_kit54.getU128Encoder)()],
+      ["bump", (0, import_kit54.getU8Encoder)()],
+      ["owner", (0, import_kit54.getAddressEncoder)()],
+      ["market", (0, import_kit54.getAddressEncoder)()],
+      ["userPubkey", (0, import_kit54.getArrayEncoder)((0, import_kit54.getU8Encoder)(), { size: 32 })],
       [
         "encryptedOptionDisclosure",
-        (0, import_kit56.getArrayEncoder)((0, import_kit56.getU8Encoder)(), { size: 32 })
+        (0, import_kit54.getArrayEncoder)((0, import_kit54.getU8Encoder)(), { size: 32 })
       ],
-      ["stateNonceDisclosure", (0, import_kit56.getU128Encoder)()],
-      ["stakedAtTimestamp", (0, import_kit56.getOptionEncoder)((0, import_kit56.getU64Encoder)())],
-      ["unstakedAtTimestamp", (0, import_kit56.getOptionEncoder)((0, import_kit56.getU64Encoder)())],
-      ["amount", (0, import_kit56.getU64Encoder)()],
+      ["stateNonceDisclosure", (0, import_kit54.getU128Encoder)()],
+      ["stakedAtTimestamp", (0, import_kit54.getOptionEncoder)((0, import_kit54.getU64Encoder)())],
+      ["unstakedAtTimestamp", (0, import_kit54.getOptionEncoder)((0, import_kit54.getU64Encoder)())],
+      ["amount", (0, import_kit54.getU64Encoder)()],
       ["collectedFees", getCollectedFeesEncoder()],
-      ["revealedOption", (0, import_kit56.getOptionEncoder)((0, import_kit56.getU64Encoder)())],
-      ["score", (0, import_kit56.getOptionEncoder)((0, import_kit56.getU64Encoder)())],
-      ["unstaked", (0, import_kit56.getBooleanEncoder)()],
-      ["id", (0, import_kit56.getU32Encoder)()],
-      ["pendingStakeComputation", (0, import_kit56.getOptionEncoder)((0, import_kit56.getAddressEncoder)())],
-      ["pendingReveal", (0, import_kit56.getBooleanEncoder)()]
+      ["revealedOption", (0, import_kit54.getOptionEncoder)((0, import_kit54.getU64Encoder)())],
+      ["score", (0, import_kit54.getOptionEncoder)((0, import_kit54.getU64Encoder)())],
+      ["unstaked", (0, import_kit54.getBooleanEncoder)()],
+      ["id", (0, import_kit54.getU32Encoder)()],
+      ["pendingStakeComputation", (0, import_kit54.getOptionEncoder)((0, import_kit54.getAddressEncoder)())],
+      ["pendingReveal", (0, import_kit54.getBooleanEncoder)()]
     ]),
     (value) => ({ ...value, discriminator: STAKE_ACCOUNT_DISCRIMINATOR })
   );
 }
 function getStakeAccountDecoder() {
-  return (0, import_kit56.getStructDecoder)([
-    ["discriminator", (0, import_kit56.fixDecoderSize)((0, import_kit56.getBytesDecoder)(), 8)],
-    ["encryptedOption", (0, import_kit56.getArrayDecoder)((0, import_kit56.getU8Decoder)(), { size: 32 })],
-    ["stateNonce", (0, import_kit56.getU128Decoder)()],
-    ["bump", (0, import_kit56.getU8Decoder)()],
-    ["owner", (0, import_kit56.getAddressDecoder)()],
-    ["market", (0, import_kit56.getAddressDecoder)()],
-    ["userPubkey", (0, import_kit56.getArrayDecoder)((0, import_kit56.getU8Decoder)(), { size: 32 })],
+  return (0, import_kit54.getStructDecoder)([
+    ["discriminator", (0, import_kit54.fixDecoderSize)((0, import_kit54.getBytesDecoder)(), 8)],
+    ["encryptedOption", (0, import_kit54.getArrayDecoder)((0, import_kit54.getU8Decoder)(), { size: 32 })],
+    ["stateNonce", (0, import_kit54.getU128Decoder)()],
+    ["bump", (0, import_kit54.getU8Decoder)()],
+    ["owner", (0, import_kit54.getAddressDecoder)()],
+    ["market", (0, import_kit54.getAddressDecoder)()],
+    ["userPubkey", (0, import_kit54.getArrayDecoder)((0, import_kit54.getU8Decoder)(), { size: 32 })],
     [
       "encryptedOptionDisclosure",
-      (0, import_kit56.getArrayDecoder)((0, import_kit56.getU8Decoder)(), { size: 32 })
+      (0, import_kit54.getArrayDecoder)((0, import_kit54.getU8Decoder)(), { size: 32 })
     ],
-    ["stateNonceDisclosure", (0, import_kit56.getU128Decoder)()],
-    ["stakedAtTimestamp", (0, import_kit56.getOptionDecoder)((0, import_kit56.getU64Decoder)())],
-    ["unstakedAtTimestamp", (0, import_kit56.getOptionDecoder)((0, import_kit56.getU64Decoder)())],
-    ["amount", (0, import_kit56.getU64Decoder)()],
+    ["stateNonceDisclosure", (0, import_kit54.getU128Decoder)()],
+    ["stakedAtTimestamp", (0, import_kit54.getOptionDecoder)((0, import_kit54.getU64Decoder)())],
+    ["unstakedAtTimestamp", (0, import_kit54.getOptionDecoder)((0, import_kit54.getU64Decoder)())],
+    ["amount", (0, import_kit54.getU64Decoder)()],
     ["collectedFees", getCollectedFeesDecoder()],
-    ["revealedOption", (0, import_kit56.getOptionDecoder)((0, import_kit56.getU64Decoder)())],
-    ["score", (0, import_kit56.getOptionDecoder)((0, import_kit56.getU64Decoder)())],
-    ["unstaked", (0, import_kit56.getBooleanDecoder)()],
-    ["id", (0, import_kit56.getU32Decoder)()],
-    ["pendingStakeComputation", (0, import_kit56.getOptionDecoder)((0, import_kit56.getAddressDecoder)())],
-    ["pendingReveal", (0, import_kit56.getBooleanDecoder)()]
+    ["revealedOption", (0, import_kit54.getOptionDecoder)((0, import_kit54.getU64Decoder)())],
+    ["score", (0, import_kit54.getOptionDecoder)((0, import_kit54.getU64Decoder)())],
+    ["unstaked", (0, import_kit54.getBooleanDecoder)()],
+    ["id", (0, import_kit54.getU32Decoder)()],
+    ["pendingStakeComputation", (0, import_kit54.getOptionDecoder)((0, import_kit54.getAddressDecoder)())],
+    ["pendingReveal", (0, import_kit54.getBooleanDecoder)()]
   ]);
 }
 function getStakeAccountCodec() {
-  return (0, import_kit56.combineCodec)(getStakeAccountEncoder(), getStakeAccountDecoder());
+  return (0, import_kit54.combineCodec)(getStakeAccountEncoder(), getStakeAccountDecoder());
 }
 function decodeStakeAccount(encodedAccount) {
-  return (0, import_kit56.decodeAccount)(
+  return (0, import_kit54.decodeAccount)(
     encodedAccount,
     getStakeAccountDecoder()
   );
 }
 async function fetchStakeAccount(rpc, address3, config) {
   const maybeAccount = await fetchMaybeStakeAccount(rpc, address3, config);
-  (0, import_kit56.assertAccountExists)(maybeAccount);
+  (0, import_kit54.assertAccountExists)(maybeAccount);
   return maybeAccount;
 }
 async function fetchMaybeStakeAccount(rpc, address3, config) {
-  const maybeAccount = await (0, import_kit56.fetchEncodedAccount)(rpc, address3, config);
+  const maybeAccount = await (0, import_kit54.fetchEncodedAccount)(rpc, address3, config);
   return decodeStakeAccount(maybeAccount);
 }
 async function fetchAllStakeAccount(rpc, addresses, config) {
   const maybeAccounts = await fetchAllMaybeStakeAccount(rpc, addresses, config);
-  (0, import_kit56.assertAccountsExist)(maybeAccounts);
+  (0, import_kit54.assertAccountsExist)(maybeAccounts);
   return maybeAccounts;
 }
 async function fetchAllMaybeStakeAccount(rpc, addresses, config) {
-  const maybeAccounts = await (0, import_kit56.fetchEncodedAccounts)(rpc, addresses, config);
+  const maybeAccounts = await (0, import_kit54.fetchEncodedAccounts)(rpc, addresses, config);
   return maybeAccounts.map((maybeAccount) => decodeStakeAccount(maybeAccount));
 }
 
 // src/generated/errors/opportunityMarket.ts
-var import_kit58 = require("@solana/kit");
+var import_kit56 = require("@solana/kit");
 
 // src/generated/programs/opportunityMarket.ts
-var import_kit57 = require("@solana/kit");
+var import_kit55 = require("@solana/kit");
 var OPPORTUNITY_MARKET_PROGRAM_ADDRESS = "B3NCHsGBkdZrPYPJY2rjg4UwmyRotMmFWhxa5hMHwLeg";
 var OpportunityMarketAccount = /* @__PURE__ */ ((OpportunityMarketAccount2) => {
   OpportunityMarketAccount2[OpportunityMarketAccount2["AllowedMint"] = 0] = "AllowedMint";
@@ -2598,63 +2530,63 @@ var OpportunityMarketAccount = /* @__PURE__ */ ((OpportunityMarketAccount2) => {
 })(OpportunityMarketAccount || {});
 function identifyOpportunityMarketAccount(account) {
   const data = "data" in account ? account.data : account;
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([173, 229, 179, 46, 121, 164, 247, 6])
     ),
     0
   )) {
     return 0 /* AllowedMint */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([214, 157, 122, 114, 117, 44, 214, 74])
     ),
     0
   )) {
     return 1 /* ArciumSignerAccount */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([207, 103, 169, 160, 157, 215, 97, 224])
     ),
     0
   )) {
     return 2 /* OpportunityMarket */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([220, 236, 171, 213, 170, 117, 10, 64])
     ),
     0
   )) {
     return 3 /* OpportunityMarketOption */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([207, 139, 192, 91, 37, 190, 2, 192])
     ),
     0
   )) {
     return 4 /* OpportunityMarketSponsor */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([160, 78, 128, 0, 248, 83, 230, 160])
     ),
     0
   )) {
     return 5 /* PlatformConfig */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([80, 158, 67, 124, 50, 189, 192, 255])
     ),
     0
@@ -2680,285 +2612,265 @@ var OpportunityMarketInstruction = /* @__PURE__ */ ((OpportunityMarketInstructio
   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["RevealStake"] = 17] = "RevealStake";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealStakeCallback"] = 18] = "RevealStakeCallback";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealStakeCompDef"] = 19] = "RevealStakeCompDef";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["SetFeeClaimAuthority"] = 20] = "SetFeeClaimAuthority";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["SetUpdateAuthority"] = 21] = "SetUpdateAuthority";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["SetWinningOption"] = 22] = "SetWinningOption";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["Stake"] = 23] = "Stake";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["StakeCallback"] = 24] = "StakeCallback";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["StakeCompDef"] = 25] = "StakeCompDef";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["Unstake"] = 26] = "Unstake";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["UpdatePlatformConfig"] = 27] = "UpdatePlatformConfig";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["WithdrawReward"] = 28] = "WithdrawReward";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["ResolveMarket"] = 14] = "ResolveMarket";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealStake"] = 15] = "RevealStake";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealStakeCallback"] = 16] = "RevealStakeCallback";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealStakeCompDef"] = 17] = "RevealStakeCompDef";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["SetFeeClaimAuthority"] = 18] = "SetFeeClaimAuthority";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["SetUpdateAuthority"] = 19] = "SetUpdateAuthority";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["SetWinningOption"] = 20] = "SetWinningOption";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["Stake"] = 21] = "Stake";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["StakeCallback"] = 22] = "StakeCallback";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["StakeCompDef"] = 23] = "StakeCompDef";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["Unstake"] = 24] = "Unstake";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["UpdatePlatformConfig"] = 25] = "UpdatePlatformConfig";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["WithdrawReward"] = 26] = "WithdrawReward";
   return OpportunityMarketInstruction2;
 })(OpportunityMarketInstruction || {});
 function identifyOpportunityMarketInstruction(instruction) {
   const data = "data" in instruction ? instruction.data : instruction;
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([76, 189, 93, 144, 50, 229, 250, 116])
     ),
     0
   )) {
     return 0 /* AddMarketOption */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([4, 114, 188, 164, 149, 249, 198, 237])
     ),
     0
   )) {
     return 1 /* AddReward */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([0, 23, 125, 234, 156, 118, 134, 89])
     ),
     0
   )) {
     return 2 /* ClaimCreatorFees */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([82, 251, 233, 156, 12, 52, 184, 202])
     ),
     0
   )) {
     return 3 /* ClaimFees */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([46, 121, 107, 240, 123, 190, 229, 1])
     ),
     0
   )) {
     return 4 /* CloseOptionAccount */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([246, 236, 59, 167, 115, 135, 122, 12])
     ),
     0
   )) {
     return 5 /* CloseStakeAccount */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([41, 239, 108, 203, 185, 230, 165, 181])
     ),
     0
   )) {
     return 6 /* CloseStuckStakeAccount */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([103, 226, 97, 235, 200, 188, 251, 254])
     ),
     0
   )) {
     return 7 /* CreateMarket */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([144, 81, 42, 65, 127, 60, 134, 92])
     ),
     0
   )) {
     return 8 /* EndRevealPeriod */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([92, 201, 94, 219, 117, 53, 255, 230])
     ),
     0
   )) {
     return 9 /* FinalizeRevealStake */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([215, 70, 3, 5, 42, 229, 151, 10])
     ),
     0
   )) {
     return 10 /* InitAllowedMint */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([101, 52, 47, 49, 156, 16, 32, 118])
     ),
     0
   )) {
     return 11 /* InitPlatformConfig */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([132, 171, 255, 149, 163, 37, 220, 45])
     ),
     0
   )) {
     return 12 /* InitStakeAccount */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([116, 19, 123, 75, 217, 244, 69, 44])
     ),
     0
   )) {
     return 13 /* OpenMarket */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
-      new Uint8Array([245, 191, 35, 58, 88, 250, 229, 60])
-    ),
-    0
-  )) {
-    return 14 /* PauseStaking */;
-  }
-  if ((0, import_kit57.containsBytes)(
-    data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([155, 23, 80, 173, 46, 74, 23, 239])
     ),
     0
   )) {
-    return 15 /* ResolveMarket */;
-  }
-  if ((0, import_kit57.containsBytes)(
-    data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
-      new Uint8Array([31, 200, 175, 23, 211, 22, 63, 155])
-    ),
-    0
-  )) {
-    return 16 /* ResumeStaking */;
+    return 14 /* ResolveMarket */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([107, 229, 210, 77, 126, 255, 243, 188])
     ),
     0
   )) {
-    return 17 /* RevealStake */;
+    return 15 /* RevealStake */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([79, 19, 120, 162, 232, 39, 206, 116])
     ),
     0
   )) {
-    return 18 /* RevealStakeCallback */;
+    return 16 /* RevealStakeCallback */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([197, 20, 216, 132, 43, 99, 64, 0])
     ),
     0
   )) {
-    return 19 /* RevealStakeCompDef */;
+    return 17 /* RevealStakeCompDef */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([75, 250, 161, 197, 43, 196, 161, 3])
     ),
     0
   )) {
-    return 20 /* SetFeeClaimAuthority */;
+    return 18 /* SetFeeClaimAuthority */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([166, 198, 186, 255, 217, 170, 103, 155])
     ),
     0
   )) {
-    return 21 /* SetUpdateAuthority */;
+    return 19 /* SetUpdateAuthority */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([156, 73, 113, 33, 170, 115, 163, 206])
     ),
     0
   )) {
-    return 22 /* SetWinningOption */;
+    return 20 /* SetWinningOption */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([206, 176, 202, 18, 200, 209, 179, 108])
     ),
     0
   )) {
-    return 23 /* Stake */;
+    return 21 /* Stake */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([40, 220, 36, 47, 6, 116, 132, 89])
     ),
     0
   )) {
-    return 24 /* StakeCallback */;
+    return 22 /* StakeCallback */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([156, 5, 60, 126, 142, 149, 1, 130])
     ),
     0
   )) {
-    return 25 /* StakeCompDef */;
+    return 23 /* StakeCompDef */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([90, 95, 107, 42, 205, 124, 50, 225])
     ),
     0
   )) {
-    return 26 /* Unstake */;
+    return 24 /* Unstake */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([195, 60, 76, 129, 146, 45, 67, 143])
     ),
     0
   )) {
-    return 27 /* UpdatePlatformConfig */;
+    return 25 /* UpdatePlatformConfig */;
   }
-  if ((0, import_kit57.containsBytes)(
+  if ((0, import_kit55.containsBytes)(
     data,
-    (0, import_kit57.fixEncoderSize)((0, import_kit57.getBytesEncoder)(), 8).encode(
+    (0, import_kit55.fixEncoderSize)((0, import_kit55.getBytesEncoder)(), 8).encode(
       new Uint8Array([191, 187, 176, 137, 9, 25, 187, 244])
     ),
     0
   )) {
-    return 28 /* WithdrawReward */;
+    return 26 /* WithdrawReward */;
   }
   throw new Error(
     "The provided instruction could not be identified as a opportunityMarket instruction."
@@ -2992,16 +2904,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 (process.env.NODE_ENV !== "production") {
   opportunityMarketErrorMessages = {
@@ -3022,10 +2933,9 @@ if (process.env.NODE_ENV !== "production") {
     [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`,
@@ -3050,7 +2960,7 @@ function getOpportunityMarketErrorMessage(code) {
   return "Error message not available in production bundles.";
 }
 function isOpportunityMarketError(error, transactionMessage, code) {
-  return (0, import_kit58.isProgramError)(
+  return (0, import_kit56.isProgramError)(
     error,
     transactionMessage,
     OPPORTUNITY_MARKET_PROGRAM_ADDRESS,
@@ -3059,10 +2969,10 @@ function isOpportunityMarketError(error, transactionMessage, code) {
 }
 
 // src/generated/instructions/addMarketOption.ts
-var import_kit60 = require("@solana/kit");
+var import_kit58 = require("@solana/kit");
 
 // src/generated/shared/index.ts
-var import_kit59 = require("@solana/kit");
+var import_kit57 = require("@solana/kit");
 function expectSome(value) {
   if (value === null || value === void 0) {
     throw new Error("Expected a value but received null or undefined.");
@@ -3087,19 +2997,19 @@ function getAccountMetaFactory(programAddress, optionalAccountStrategy) {
       if (optionalAccountStrategy === "omitted") return;
       return Object.freeze({
         address: programAddress,
-        role: import_kit59.AccountRole.READONLY
+        role: import_kit57.AccountRole.READONLY
       });
     }
-    const writableRole = account.isWritable ? import_kit59.AccountRole.WRITABLE : import_kit59.AccountRole.READONLY;
+    const writableRole = account.isWritable ? import_kit57.AccountRole.WRITABLE : import_kit57.AccountRole.READONLY;
     return Object.freeze({
       address: expectAddress(account.value),
-      role: isTransactionSigner(account.value) ? (0, import_kit59.upgradeRoleToSigner)(writableRole) : writableRole,
+      role: isTransactionSigner(account.value) ? (0, import_kit57.upgradeRoleToSigner)(writableRole) : writableRole,
       ...isTransactionSigner(account.value) ? { signer: account.value } : {}
     });
   };
 }
 function isTransactionSigner(value) {
-  return !!value && typeof value === "object" && "address" in value && (0, import_kit59.isTransactionSigner)(value);
+  return !!value && typeof value === "object" && "address" in value && (0, import_kit57.isTransactionSigner)(value);
 }
 
 // src/generated/instructions/addMarketOption.ts
@@ -3114,27 +3024,27 @@ var ADD_MARKET_OPTION_DISCRIMINATOR = new Uint8Array([
   116
 ]);
 function getAddMarketOptionDiscriminatorBytes() {
-  return (0, import_kit60.fixEncoderSize)((0, import_kit60.getBytesEncoder)(), 8).encode(
+  return (0, import_kit58.fixEncoderSize)((0, import_kit58.getBytesEncoder)(), 8).encode(
     ADD_MARKET_OPTION_DISCRIMINATOR
   );
 }
 function getAddMarketOptionInstructionDataEncoder() {
-  return (0, import_kit60.transformEncoder)(
-    (0, import_kit60.getStructEncoder)([
-      ["discriminator", (0, import_kit60.fixEncoderSize)((0, import_kit60.getBytesEncoder)(), 8)],
-      ["optionId", (0, import_kit60.getU64Encoder)()]
+  return (0, import_kit58.transformEncoder)(
+    (0, import_kit58.getStructEncoder)([
+      ["discriminator", (0, import_kit58.fixEncoderSize)((0, import_kit58.getBytesEncoder)(), 8)],
+      ["optionId", (0, import_kit58.getU64Encoder)()]
     ]),
     (value) => ({ ...value, discriminator: ADD_MARKET_OPTION_DISCRIMINATOR })
   );
 }
 function getAddMarketOptionInstructionDataDecoder() {
-  return (0, import_kit60.getStructDecoder)([
-    ["discriminator", (0, import_kit60.fixDecoderSize)((0, import_kit60.getBytesDecoder)(), 8)],
-    ["optionId", (0, import_kit60.getU64Decoder)()]
+  return (0, import_kit58.getStructDecoder)([
+    ["discriminator", (0, import_kit58.fixDecoderSize)((0, import_kit58.getBytesDecoder)(), 8)],
+    ["optionId", (0, import_kit58.getU64Decoder)()]
   ]);
 }
 function getAddMarketOptionInstructionDataCodec() {
-  return (0, import_kit60.combineCodec)(
+  return (0, import_kit58.combineCodec)(
     getAddMarketOptionInstructionDataEncoder(),
     getAddMarketOptionInstructionDataDecoder()
   );
@@ -3150,14 +3060,14 @@ async function getAddMarketOptionInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.option.value) {
-    accounts.option.value = await (0, import_kit60.getProgramDerivedAddress)({
+    accounts.option.value = await (0, import_kit58.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        (0, import_kit60.getBytesEncoder)().encode(
+        (0, import_kit58.getBytesEncoder)().encode(
           new Uint8Array([111, 112, 116, 105, 111, 110])
         ),
-        (0, import_kit60.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit60.getU64Encoder)().encode(expectSome(args.optionId))
+        (0, import_kit58.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit58.getU64Encoder)().encode(expectSome(args.optionId))
       ]
     });
   }
@@ -3228,7 +3138,7 @@ function parseAddMarketOptionInstruction(instruction) {
 }
 
 // src/generated/instructions/addReward.ts
-var import_kit61 = require("@solana/kit");
+var import_kit59 = require("@solana/kit");
 var ADD_REWARD_DISCRIMINATOR = new Uint8Array([
   4,
   114,
@@ -3240,27 +3150,27 @@ var ADD_REWARD_DISCRIMINATOR = new Uint8Array([
   237
 ]);
 function getAddRewardDiscriminatorBytes() {
-  return (0, import_kit61.fixEncoderSize)((0, import_kit61.getBytesEncoder)(), 8).encode(ADD_REWARD_DISCRIMINATOR);
+  return (0, import_kit59.fixEncoderSize)((0, import_kit59.getBytesEncoder)(), 8).encode(ADD_REWARD_DISCRIMINATOR);
 }
 function getAddRewardInstructionDataEncoder() {
-  return (0, import_kit61.transformEncoder)(
-    (0, import_kit61.getStructEncoder)([
-      ["discriminator", (0, import_kit61.fixEncoderSize)((0, import_kit61.getBytesEncoder)(), 8)],
-      ["amount", (0, import_kit61.getU64Encoder)()],
-      ["lock", (0, import_kit61.getBooleanEncoder)()]
+  return (0, import_kit59.transformEncoder)(
+    (0, import_kit59.getStructEncoder)([
+      ["discriminator", (0, import_kit59.fixEncoderSize)((0, import_kit59.getBytesEncoder)(), 8)],
+      ["amount", (0, import_kit59.getU64Encoder)()],
+      ["lock", (0, import_kit59.getBooleanEncoder)()]
     ]),
     (value) => ({ ...value, discriminator: ADD_REWARD_DISCRIMINATOR })
   );
 }
 function getAddRewardInstructionDataDecoder() {
-  return (0, import_kit61.getStructDecoder)([
-    ["discriminator", (0, import_kit61.fixDecoderSize)((0, import_kit61.getBytesDecoder)(), 8)],
-    ["amount", (0, import_kit61.getU64Decoder)()],
-    ["lock", (0, import_kit61.getBooleanDecoder)()]
+  return (0, import_kit59.getStructDecoder)([
+    ["discriminator", (0, import_kit59.fixDecoderSize)((0, import_kit59.getBytesDecoder)(), 8)],
+    ["amount", (0, import_kit59.getU64Decoder)()],
+    ["lock", (0, import_kit59.getBooleanDecoder)()]
   ]);
 }
 function getAddRewardInstructionDataCodec() {
-  return (0, import_kit61.combineCodec)(
+  return (0, import_kit59.combineCodec)(
     getAddRewardInstructionDataEncoder(),
     getAddRewardInstructionDataDecoder()
   );
@@ -3283,24 +3193,24 @@ async function getAddRewardInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.sponsorAccount.value) {
-    accounts.sponsorAccount.value = await (0, import_kit61.getProgramDerivedAddress)({
+    accounts.sponsorAccount.value = await (0, import_kit59.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        (0, import_kit61.getBytesEncoder)().encode(
+        (0, import_kit59.getBytesEncoder)().encode(
           new Uint8Array([115, 112, 111, 110, 115, 111, 114])
         ),
-        (0, import_kit61.getAddressEncoder)().encode(expectAddress(accounts.sponsor.value)),
-        (0, import_kit61.getAddressEncoder)().encode(expectAddress(accounts.market.value))
+        (0, import_kit59.getAddressEncoder)().encode(expectAddress(accounts.sponsor.value)),
+        (0, import_kit59.getAddressEncoder)().encode(expectAddress(accounts.market.value))
       ]
     });
   }
   if (!accounts.marketTokenAta.value) {
-    accounts.marketTokenAta.value = await (0, import_kit61.getProgramDerivedAddress)({
+    accounts.marketTokenAta.value = await (0, import_kit59.getProgramDerivedAddress)({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        (0, import_kit61.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit61.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
-        (0, import_kit61.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
+        (0, import_kit59.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit59.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
+        (0, import_kit59.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -3390,7 +3300,7 @@ function parseAddRewardInstruction(instruction) {
 }
 
 // src/generated/instructions/claimCreatorFees.ts
-var import_kit62 = require("@solana/kit");
+var import_kit60 = require("@solana/kit");
 var CLAIM_CREATOR_FEES_DISCRIMINATOR = new Uint8Array([
   0,
   23,
@@ -3402,23 +3312,23 @@ var CLAIM_CREATOR_FEES_DISCRIMINATOR = new Uint8Array([
   89
 ]);
 function getClaimCreatorFeesDiscriminatorBytes() {
-  return (0, import_kit62.fixEncoderSize)((0, import_kit62.getBytesEncoder)(), 8).encode(
+  return (0, import_kit60.fixEncoderSize)((0, import_kit60.getBytesEncoder)(), 8).encode(
     CLAIM_CREATOR_FEES_DISCRIMINATOR
   );
 }
 function getClaimCreatorFeesInstructionDataEncoder() {
-  return (0, import_kit62.transformEncoder)(
-    (0, import_kit62.getStructEncoder)([["discriminator", (0, import_kit62.fixEncoderSize)((0, import_kit62.getBytesEncoder)(), 8)]]),
+  return (0, import_kit60.transformEncoder)(
+    (0, import_kit60.getStructEncoder)([["discriminator", (0, import_kit60.fixEncoderSize)((0, import_kit60.getBytesEncoder)(), 8)]]),
     (value) => ({ ...value, discriminator: CLAIM_CREATOR_FEES_DISCRIMINATOR })
   );
 }
 function getClaimCreatorFeesInstructionDataDecoder() {
-  return (0, import_kit62.getStructDecoder)([
-    ["discriminator", (0, import_kit62.fixDecoderSize)((0, import_kit62.getBytesDecoder)(), 8)]
+  return (0, import_kit60.getStructDecoder)([
+    ["discriminator", (0, import_kit60.fixDecoderSize)((0, import_kit60.getBytesDecoder)(), 8)]
   ]);
 }
 function getClaimCreatorFeesInstructionDataCodec() {
-  return (0, import_kit62.combineCodec)(
+  return (0, import_kit60.combineCodec)(
     getClaimCreatorFeesInstructionDataEncoder(),
     getClaimCreatorFeesInstructionDataDecoder()
   );
@@ -3438,12 +3348,12 @@ async function getClaimCreatorFeesInstructionAsync(input, config) {
   };
   const accounts = originalAccounts;
   if (!accounts.marketTokenAta.value) {
-    accounts.marketTokenAta.value = await (0, import_kit62.getProgramDerivedAddress)({
+    accounts.marketTokenAta.value = await (0, import_kit60.getProgramDerivedAddress)({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        (0, import_kit62.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit62.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
-        (0, import_kit62.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
+        (0, import_kit60.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit60.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
+        (0, import_kit60.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -3514,7 +3424,7 @@ function parseClaimCreatorFeesInstruction(instruction) {
 }
 
 // src/generated/instructions/claimFees.ts
-var import_kit63 = require("@solana/kit");
+var import_kit61 = require("@solana/kit");
 var CLAIM_FEES_DISCRIMINATOR = new Uint8Array([
   82,
   251,
@@ -3526,21 +3436,21 @@ var CLAIM_FEES_DISCRIMINATOR = new Uint8Array([
   202
 ]);
 function getClaimFeesDiscriminatorBytes() {
-  return (0, import_kit63.fixEncoderSize)((0, import_kit63.getBytesEncoder)(), 8).encode(CLAIM_FEES_DISCRIMINATOR);
+  return (0, import_kit61.fixEncoderSize)((0, import_kit61.getBytesEncoder)(), 8).encode(CLAIM_FEES_DISCRIMINATOR);
 }
 function getClaimFeesInstructionDataEncoder() {
-  return (0, import_kit63.transformEncoder)(
-    (0, import_kit63.getStructEncoder)([["discriminator", (0, import_kit63.fixEncoderSize)((0, import_kit63.getBytesEncoder)(), 8)]]),
+  return (0, import_kit61.transformEncoder)(
+    (0, import_kit61.getStructEncoder)([["discriminator", (0, import_kit61.fixEncoderSize)((0, import_kit61.getBytesEncoder)(), 8)]]),
     (value) => ({ ...value, discriminator: CLAIM_FEES_DISCRIMINATOR })
   );
 }
 function getClaimFeesInstructionDataDecoder() {
-  return (0, import_kit63.getStructDecoder)([
-    ["discriminator", (0, import_kit63.fixDecoderSize)((0, import_kit63.getBytesDecoder)(), 8)]
+  return (0, import_kit61.getStructDecoder)([
+    ["discriminator", (0, import_kit61.fixDecoderSize)((0, import_kit61.getBytesDecoder)(), 8)]
   ]);
 }
 function getClaimFeesInstructionDataCodec() {
-  return (0, import_kit63.combineCodec)(
+  return (0, import_kit61.combineCodec)(
     getClaimFeesInstructionDataEncoder(),
     getClaimFeesInstructionDataDecoder()
   );
@@ -3561,12 +3471,12 @@ async function getClaimFeesInstructionAsync(input, config) {
   };
   const accounts = originalAccounts;
   if (!accounts.marketTokenAta.value) {
-    accounts.marketTokenAta.value = await (0, import_kit63.getProgramDerivedAddress)({
+    accounts.marketTokenAta.value = await (0, import_kit61.getProgramDerivedAddress)({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        (0, import_kit63.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit63.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
-        (0, import_kit63.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
+        (0, import_kit61.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit61.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
+        (0, import_kit61.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -3641,7 +3551,7 @@ function parseClaimFeesInstruction(instruction) {
 }
 
 // src/generated/instructions/closeOptionAccount.ts
-var import_kit64 = require("@solana/kit");
+var import_kit62 = require("@solana/kit");
 var CLOSE_OPTION_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   46,
   121,
@@ -3653,27 +3563,27 @@ var CLOSE_OPTION_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   1
 ]);
 function getCloseOptionAccountDiscriminatorBytes() {
-  return (0, import_kit64.fixEncoderSize)((0, import_kit64.getBytesEncoder)(), 8).encode(
+  return (0, import_kit62.fixEncoderSize)((0, import_kit62.getBytesEncoder)(), 8).encode(
     CLOSE_OPTION_ACCOUNT_DISCRIMINATOR
   );
 }
 function getCloseOptionAccountInstructionDataEncoder() {
-  return (0, import_kit64.transformEncoder)(
-    (0, import_kit64.getStructEncoder)([
-      ["discriminator", (0, import_kit64.fixEncoderSize)((0, import_kit64.getBytesEncoder)(), 8)],
-      ["optionId", (0, import_kit64.getU64Encoder)()]
+  return (0, import_kit62.transformEncoder)(
+    (0, import_kit62.getStructEncoder)([
+      ["discriminator", (0, import_kit62.fixEncoderSize)((0, import_kit62.getBytesEncoder)(), 8)],
+      ["optionId", (0, import_kit62.getU64Encoder)()]
     ]),
     (value) => ({ ...value, discriminator: CLOSE_OPTION_ACCOUNT_DISCRIMINATOR })
   );
 }
 function getCloseOptionAccountInstructionDataDecoder() {
-  return (0, import_kit64.getStructDecoder)([
-    ["discriminator", (0, import_kit64.fixDecoderSize)((0, import_kit64.getBytesDecoder)(), 8)],
-    ["optionId", (0, import_kit64.getU64Decoder)()]
+  return (0, import_kit62.getStructDecoder)([
+    ["discriminator", (0, import_kit62.fixDecoderSize)((0, import_kit62.getBytesDecoder)(), 8)],
+    ["optionId", (0, import_kit62.getU64Decoder)()]
   ]);
 }
 function getCloseOptionAccountInstructionDataCodec() {
-  return (0, import_kit64.combineCodec)(
+  return (0, import_kit62.combineCodec)(
     getCloseOptionAccountInstructionDataEncoder(),
     getCloseOptionAccountInstructionDataDecoder()
   );
@@ -3690,14 +3600,14 @@ async function getCloseOptionAccountInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.option.value) {
-    accounts.option.value = await (0, import_kit64.getProgramDerivedAddress)({
+    accounts.option.value = await (0, import_kit62.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        (0, import_kit64.getBytesEncoder)().encode(
+        (0, import_kit62.getBytesEncoder)().encode(
           new Uint8Array([111, 112, 116, 105, 111, 110])
         ),
-        (0, import_kit64.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit64.getU64Encoder)().encode(expectSome(args.optionId))
+        (0, import_kit62.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit62.getU64Encoder)().encode(expectSome(args.optionId))
       ]
     });
   }
@@ -3774,7 +3684,7 @@ function parseCloseOptionAccountInstruction(instruction) {
 }
 
 // src/generated/instructions/closeStakeAccount.ts
-var import_kit65 = require("@solana/kit");
+var import_kit63 = require("@solana/kit");
 var CLOSE_STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   246,
   236,
@@ -3786,29 +3696,29 @@ var CLOSE_STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   12
 ]);
 function getCloseStakeAccountDiscriminatorBytes() {
-  return (0, import_kit65.fixEncoderSize)((0, import_kit65.getBytesEncoder)(), 8).encode(
+  return (0, import_kit63.fixEncoderSize)((0, import_kit63.getBytesEncoder)(), 8).encode(
     CLOSE_STAKE_ACCOUNT_DISCRIMINATOR
   );
 }
 function getCloseStakeAccountInstructionDataEncoder() {
-  return (0, import_kit65.transformEncoder)(
-    (0, import_kit65.getStructEncoder)([
-      ["discriminator", (0, import_kit65.fixEncoderSize)((0, import_kit65.getBytesEncoder)(), 8)],
-      ["optionId", (0, import_kit65.getU64Encoder)()],
-      ["stakeAccountId", (0, import_kit65.getU32Encoder)()]
+  return (0, import_kit63.transformEncoder)(
+    (0, import_kit63.getStructEncoder)([
+      ["discriminator", (0, import_kit63.fixEncoderSize)((0, import_kit63.getBytesEncoder)(), 8)],
+      ["optionId", (0, import_kit63.getU64Encoder)()],
+      ["stakeAccountId", (0, import_kit63.getU32Encoder)()]
     ]),
     (value) => ({ ...value, discriminator: CLOSE_STAKE_ACCOUNT_DISCRIMINATOR })
   );
 }
 function getCloseStakeAccountInstructionDataDecoder() {
-  return (0, import_kit65.getStructDecoder)([
-    ["discriminator", (0, import_kit65.fixDecoderSize)((0, import_kit65.getBytesDecoder)(), 8)],
-    ["optionId", (0, import_kit65.getU64Decoder)()],
-    ["stakeAccountId", (0, import_kit65.getU32Decoder)()]
+  return (0, import_kit63.getStructDecoder)([
+    ["discriminator", (0, import_kit63.fixDecoderSize)((0, import_kit63.getBytesDecoder)(), 8)],
+    ["optionId", (0, import_kit63.getU64Decoder)()],
+    ["stakeAccountId", (0, import_kit63.getU32Decoder)()]
   ]);
 }
 function getCloseStakeAccountInstructionDataCodec() {
-  return (0, import_kit65.combineCodec)(
+  return (0, import_kit63.combineCodec)(
     getCloseStakeAccountInstructionDataEncoder(),
     getCloseStakeAccountInstructionDataDecoder()
   );
@@ -3832,10 +3742,10 @@ async function getCloseStakeAccountInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.stakeAccount.value) {
-    accounts.stakeAccount.value = await (0, import_kit65.getProgramDerivedAddress)({
+    accounts.stakeAccount.value = await (0, import_kit63.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        (0, import_kit65.getBytesEncoder)().encode(
+        (0, import_kit63.getBytesEncoder)().encode(
           new Uint8Array([
             115,
             116,
@@ -3852,31 +3762,31 @@ async function getCloseStakeAccountInstructionAsync(input, config) {
             116
           ])
         ),
-        (0, import_kit65.getAddressEncoder)().encode(expectAddress(accounts.owner.value)),
-        (0, import_kit65.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit65.getU32Encoder)().encode(expectSome(args.stakeAccountId))
+        (0, import_kit63.getAddressEncoder)().encode(expectAddress(accounts.owner.value)),
+        (0, import_kit63.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit63.getU32Encoder)().encode(expectSome(args.stakeAccountId))
       ]
     });
   }
   if (!accounts.option.value) {
-    accounts.option.value = await (0, import_kit65.getProgramDerivedAddress)({
+    accounts.option.value = await (0, import_kit63.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        (0, import_kit65.getBytesEncoder)().encode(
+        (0, import_kit63.getBytesEncoder)().encode(
           new Uint8Array([111, 112, 116, 105, 111, 110])
         ),
-        (0, import_kit65.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit65.getU64Encoder)().encode(expectSome(args.optionId))
+        (0, import_kit63.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit63.getU64Encoder)().encode(expectSome(args.optionId))
       ]
     });
   }
   if (!accounts.marketTokenAta.value) {
-    accounts.marketTokenAta.value = await (0, import_kit65.getProgramDerivedAddress)({
+    accounts.marketTokenAta.value = await (0, import_kit63.getProgramDerivedAddress)({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        (0, import_kit65.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit65.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
-        (0, import_kit65.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
+        (0, import_kit63.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit63.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
+        (0, import_kit63.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -3970,7 +3880,7 @@ function parseCloseStakeAccountInstruction(instruction) {
 }
 
 // src/generated/instructions/closeStuckStakeAccount.ts
-var import_kit66 = require("@solana/kit");
+var import_kit64 = require("@solana/kit");
 var CLOSE_STUCK_STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   41,
   239,
@@ -3982,15 +3892,15 @@ var CLOSE_STUCK_STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   181
 ]);
 function getCloseStuckStakeAccountDiscriminatorBytes() {
-  return (0, import_kit66.fixEncoderSize)((0, import_kit66.getBytesEncoder)(), 8).encode(
+  return (0, import_kit64.fixEncoderSize)((0, import_kit64.getBytesEncoder)(), 8).encode(
     CLOSE_STUCK_STAKE_ACCOUNT_DISCRIMINATOR
   );
 }
 function getCloseStuckStakeAccountInstructionDataEncoder() {
-  return (0, import_kit66.transformEncoder)(
-    (0, import_kit66.getStructEncoder)([
-      ["discriminator", (0, import_kit66.fixEncoderSize)((0, import_kit66.getBytesEncoder)(), 8)],
-      ["stakeAccountId", (0, import_kit66.getU32Encoder)()]
+  return (0, import_kit64.transformEncoder)(
+    (0, import_kit64.getStructEncoder)([
+      ["discriminator", (0, import_kit64.fixEncoderSize)((0, import_kit64.getBytesEncoder)(), 8)],
+      ["stakeAccountId", (0, import_kit64.getU32Encoder)()]
     ]),
     (value) => ({
       ...value,
@@ -3999,13 +3909,13 @@ function getCloseStuckStakeAccountInstructionDataEncoder() {
   );
 }
 function getCloseStuckStakeAccountInstructionDataDecoder() {
-  return (0, import_kit66.getStructDecoder)([
-    ["discriminator", (0, import_kit66.fixDecoderSize)((0, import_kit66.getBytesDecoder)(), 8)],
-    ["stakeAccountId", (0, import_kit66.getU32Decoder)()]
+  return (0, import_kit64.getStructDecoder)([
+    ["discriminator", (0, import_kit64.fixDecoderSize)((0, import_kit64.getBytesDecoder)(), 8)],
+    ["stakeAccountId", (0, import_kit64.getU32Decoder)()]
   ]);
 }
 function getCloseStuckStakeAccountInstructionDataCodec() {
-  return (0, import_kit66.combineCodec)(
+  return (0, import_kit64.combineCodec)(
     getCloseStuckStakeAccountInstructionDataEncoder(),
     getCloseStuckStakeAccountInstructionDataDecoder()
   );
@@ -4028,10 +3938,10 @@ async function getCloseStuckStakeAccountInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.stakeAccount.value) {
-    accounts.stakeAccount.value = await (0, import_kit66.getProgramDerivedAddress)({
+    accounts.stakeAccount.value = await (0, import_kit64.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        (0, import_kit66.getBytesEncoder)().encode(
+        (0, import_kit64.getBytesEncoder)().encode(
           new Uint8Array([
             115,
             116,
@@ -4048,19 +3958,19 @@ async function getCloseStuckStakeAccountInstructionAsync(input, config) {
             116
           ])
         ),
-        (0, import_kit66.getAddressEncoder)().encode(expectAddress(accounts.signer.value)),
-        (0, import_kit66.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit66.getU32Encoder)().encode(expectSome(args.stakeAccountId))
+        (0, import_kit64.getAddressEncoder)().encode(expectAddress(accounts.signer.value)),
+        (0, import_kit64.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit64.getU32Encoder)().encode(expectSome(args.stakeAccountId))
       ]
     });
   }
   if (!accounts.marketTokenAta.value) {
-    accounts.marketTokenAta.value = await (0, import_kit66.getProgramDerivedAddress)({
+    accounts.marketTokenAta.value = await (0, import_kit64.getProgramDerivedAddress)({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        (0, import_kit66.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit66.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
-        (0, import_kit66.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
+        (0, import_kit64.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit64.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
+        (0, import_kit64.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -4152,7 +4062,7 @@ function parseCloseStuckStakeAccountInstruction(instruction) {
 }
 
 // src/generated/instructions/createMarket.ts
-var import_kit67 = require("@solana/kit");
+var import_kit65 = require("@solana/kit");
 var CREATE_MARKET_DISCRIMINATOR = new Uint8Array([
   103,
   226,
@@ -4164,43 +4074,41 @@ var CREATE_MARKET_DISCRIMINATOR = new Uint8Array([
   254
 ]);
 function getCreateMarketDiscriminatorBytes() {
-  return (0, import_kit67.fixEncoderSize)((0, import_kit67.getBytesEncoder)(), 8).encode(
+  return (0, import_kit65.fixEncoderSize)((0, import_kit65.getBytesEncoder)(), 8).encode(
     CREATE_MARKET_DISCRIMINATOR
   );
 }
 function getCreateMarketInstructionDataEncoder() {
-  return (0, import_kit67.transformEncoder)(
-    (0, import_kit67.getStructEncoder)([
-      ["discriminator", (0, import_kit67.fixEncoderSize)((0, import_kit67.getBytesEncoder)(), 8)],
-      ["marketIndex", (0, import_kit67.getU64Encoder)()],
-      ["marketAuthority", (0, import_kit67.getAddressEncoder)()],
-      ["allowUnstakingEarly", (0, import_kit67.getBooleanEncoder)()],
-      ["authorizedReaderPubkey", (0, import_kit67.getArrayEncoder)((0, import_kit67.getU8Encoder)(), { size: 32 })],
-      ["revealPeriodAuthority", (0, import_kit67.getAddressEncoder)()],
-      ["earlinessCutoffSeconds", (0, import_kit67.getU64Encoder)()],
-      ["earlinessMultiplier", (0, import_kit67.getU16Encoder)()],
-      ["minStakeAmount", (0, import_kit67.getU64Encoder)()],
-      ["creatorFeeClaimer", (0, import_kit67.getAddressEncoder)()]
+  return (0, import_kit65.transformEncoder)(
+    (0, import_kit65.getStructEncoder)([
+      ["discriminator", (0, import_kit65.fixEncoderSize)((0, import_kit65.getBytesEncoder)(), 8)],
+      ["marketIndex", (0, import_kit65.getU64Encoder)()],
+      ["marketAuthority", (0, import_kit65.getAddressEncoder)()],
+      ["allowUnstakingEarly", (0, import_kit65.getBooleanEncoder)()],
+      ["authorizedReaderPubkey", (0, import_kit65.getArrayEncoder)((0, import_kit65.getU8Encoder)(), { size: 32 })],
+      ["earlinessCutoffSeconds", (0, import_kit65.getU64Encoder)()],
+      ["earlinessMultiplier", (0, import_kit65.getU16Encoder)()],
+      ["minStakeAmount", (0, import_kit65.getU64Encoder)()],
+      ["creatorFeeClaimer", (0, import_kit65.getAddressEncoder)()]
     ]),
     (value) => ({ ...value, discriminator: CREATE_MARKET_DISCRIMINATOR })
   );
 }
 function getCreateMarketInstructionDataDecoder() {
-  return (0, import_kit67.getStructDecoder)([
-    ["discriminator", (0, import_kit67.fixDecoderSize)((0, import_kit67.getBytesDecoder)(), 8)],
-    ["marketIndex", (0, import_kit67.getU64Decoder)()],
-    ["marketAuthority", (0, import_kit67.getAddressDecoder)()],
-    ["allowUnstakingEarly", (0, import_kit67.getBooleanDecoder)()],
-    ["authorizedReaderPubkey", (0, import_kit67.getArrayDecoder)((0, import_kit67.getU8Decoder)(), { size: 32 })],
-    ["revealPeriodAuthority", (0, import_kit67.getAddressDecoder)()],
-    ["earlinessCutoffSeconds", (0, import_kit67.getU64Decoder)()],
-    ["earlinessMultiplier", (0, import_kit67.getU16Decoder)()],
-    ["minStakeAmount", (0, import_kit67.getU64Decoder)()],
-    ["creatorFeeClaimer", (0, import_kit67.getAddressDecoder)()]
+  return (0, import_kit65.getStructDecoder)([
+    ["discriminator", (0, import_kit65.fixDecoderSize)((0, import_kit65.getBytesDecoder)(), 8)],
+    ["marketIndex", (0, import_kit65.getU64Decoder)()],
+    ["marketAuthority", (0, import_kit65.getAddressDecoder)()],
+    ["allowUnstakingEarly", (0, import_kit65.getBooleanDecoder)()],
+    ["authorizedReaderPubkey", (0, import_kit65.getArrayDecoder)((0, import_kit65.getU8Decoder)(), { size: 32 })],
+    ["earlinessCutoffSeconds", (0, import_kit65.getU64Decoder)()],
+    ["earlinessMultiplier", (0, import_kit65.getU16Decoder)()],
+    ["minStakeAmount", (0, import_kit65.getU64Decoder)()],
+    ["creatorFeeClaimer", (0, import_kit65.getAddressDecoder)()]
   ]);
 }
 function getCreateMarketInstructionDataCodec() {
-  return (0, import_kit67.combineCodec)(
+  return (0, import_kit65.combineCodec)(
     getCreateMarketInstructionDataEncoder(),
     getCreateMarketInstructionDataDecoder()
   );
@@ -4224,10 +4132,10 @@ async function getCreateMarketInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.market.value) {
-    accounts.market.value = await (0, import_kit67.getProgramDerivedAddress)({
+    accounts.market.value = await (0, import_kit65.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        (0, import_kit67.getBytesEncoder)().encode(
+        (0, import_kit65.getBytesEncoder)().encode(
           new Uint8Array([
             111,
             112,
@@ -4249,29 +4157,29 @@ async function getCreateMarketInstructionAsync(input, config) {
             116
           ])
         ),
-        (0, import_kit67.getAddressEncoder)().encode(
+        (0, import_kit65.getAddressEncoder)().encode(
           expectAddress(accounts.platformConfig.value)
         ),
-        (0, import_kit67.getAddressEncoder)().encode(expectAddress(accounts.creator.value)),
-        (0, import_kit67.getU64Encoder)().encode(expectSome(args.marketIndex))
+        (0, import_kit65.getAddressEncoder)().encode(expectAddress(accounts.creator.value)),
+        (0, import_kit65.getU64Encoder)().encode(expectSome(args.marketIndex))
       ]
     });
   }
   if (!accounts.marketTokenAta.value) {
-    accounts.marketTokenAta.value = await (0, import_kit67.getProgramDerivedAddress)({
+    accounts.marketTokenAta.value = await (0, import_kit65.getProgramDerivedAddress)({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        (0, import_kit67.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit67.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
-        (0, import_kit67.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
+        (0, import_kit65.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit65.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
+        (0, import_kit65.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
   if (!accounts.allowedMint.value) {
-    accounts.allowedMint.value = await (0, import_kit67.getProgramDerivedAddress)({
+    accounts.allowedMint.value = await (0, import_kit65.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        (0, import_kit67.getBytesEncoder)().encode(
+        (0, import_kit65.getBytesEncoder)().encode(
           new Uint8Array([
             97,
             108,
@@ -4287,10 +4195,10 @@ async function getCreateMarketInstructionAsync(input, config) {
             116
           ])
         ),
-        (0, import_kit67.getAddressEncoder)().encode(
+        (0, import_kit65.getAddressEncoder)().encode(
           expectAddress(accounts.platformConfig.value)
         ),
-        (0, import_kit67.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
+        (0, import_kit65.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -4390,7 +4298,7 @@ function parseCreateMarketInstruction(instruction) {
 }
 
 // src/generated/instructions/endRevealPeriod.ts
-var import_kit68 = require("@solana/kit");
+var import_kit66 = require("@solana/kit");
 var END_REVEAL_PERIOD_DISCRIMINATOR = new Uint8Array([
   144,
   81,
@@ -4402,23 +4310,23 @@ var END_REVEAL_PERIOD_DISCRIMINATOR = new Uint8Array([
   92
 ]);
 function getEndRevealPeriodDiscriminatorBytes() {
-  return (0, import_kit68.fixEncoderSize)((0, import_kit68.getBytesEncoder)(), 8).encode(
+  return (0, import_kit66.fixEncoderSize)((0, import_kit66.getBytesEncoder)(), 8).encode(
     END_REVEAL_PERIOD_DISCRIMINATOR
   );
 }
 function getEndRevealPeriodInstructionDataEncoder() {
-  return (0, import_kit68.transformEncoder)(
-    (0, import_kit68.getStructEncoder)([["discriminator", (0, import_kit68.fixEncoderSize)((0, import_kit68.getBytesEncoder)(), 8)]]),
+  return (0, import_kit66.transformEncoder)(
+    (0, import_kit66.getStructEncoder)([["discriminator", (0, import_kit66.fixEncoderSize)((0, import_kit66.getBytesEncoder)(), 8)]]),
     (value) => ({ ...value, discriminator: END_REVEAL_PERIOD_DISCRIMINATOR })
   );
 }
 function getEndRevealPeriodInstructionDataDecoder() {
-  return (0, import_kit68.getStructDecoder)([
-    ["discriminator", (0, import_kit68.fixDecoderSize)((0, import_kit68.getBytesDecoder)(), 8)]
+  return (0, import_kit66.getStructDecoder)([
+    ["discriminator", (0, import_kit66.fixDecoderSize)((0, import_kit66.getBytesDecoder)(), 8)]
   ]);
 }
 function getEndRevealPeriodInstructionDataCodec() {
-  return (0, import_kit68.combineCodec)(
+  return (0, import_kit66.combineCodec)(
     getEndRevealPeriodInstructionDataEncoder(),
     getEndRevealPeriodInstructionDataDecoder()
   );
@@ -4427,21 +4335,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;
@@ -4452,13 +4362,17 @@ 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
-var import_kit69 = require("@solana/kit");
+var import_kit67 = require("@solana/kit");
 var FINALIZE_REVEAL_STAKE_DISCRIMINATOR = new Uint8Array([
   92,
   201,
@@ -4470,16 +4384,16 @@ var FINALIZE_REVEAL_STAKE_DISCRIMINATOR = new Uint8Array([
   230
 ]);
 function getFinalizeRevealStakeDiscriminatorBytes() {
-  return (0, import_kit69.fixEncoderSize)((0, import_kit69.getBytesEncoder)(), 8).encode(
+  return (0, import_kit67.fixEncoderSize)((0, import_kit67.getBytesEncoder)(), 8).encode(
     FINALIZE_REVEAL_STAKE_DISCRIMINATOR
   );
 }
 function getFinalizeRevealStakeInstructionDataEncoder() {
-  return (0, import_kit69.transformEncoder)(
-    (0, import_kit69.getStructEncoder)([
-      ["discriminator", (0, import_kit69.fixEncoderSize)((0, import_kit69.getBytesEncoder)(), 8)],
-      ["optionId", (0, import_kit69.getU64Encoder)()],
-      ["stakeAccountId", (0, import_kit69.getU32Encoder)()]
+  return (0, import_kit67.transformEncoder)(
+    (0, import_kit67.getStructEncoder)([
+      ["discriminator", (0, import_kit67.fixEncoderSize)((0, import_kit67.getBytesEncoder)(), 8)],
+      ["optionId", (0, import_kit67.getU64Encoder)()],
+      ["stakeAccountId", (0, import_kit67.getU32Encoder)()]
     ]),
     (value) => ({
       ...value,
@@ -4488,14 +4402,14 @@ function getFinalizeRevealStakeInstructionDataEncoder() {
   );
 }
 function getFinalizeRevealStakeInstructionDataDecoder() {
-  return (0, import_kit69.getStructDecoder)([
-    ["discriminator", (0, import_kit69.fixDecoderSize)((0, import_kit69.getBytesDecoder)(), 8)],
-    ["optionId", (0, import_kit69.getU64Decoder)()],
-    ["stakeAccountId", (0, import_kit69.getU32Decoder)()]
+  return (0, import_kit67.getStructDecoder)([
+    ["discriminator", (0, import_kit67.fixDecoderSize)((0, import_kit67.getBytesDecoder)(), 8)],
+    ["optionId", (0, import_kit67.getU64Decoder)()],
+    ["stakeAccountId", (0, import_kit67.getU32Decoder)()]
   ]);
 }
 function getFinalizeRevealStakeInstructionDataCodec() {
-  return (0, import_kit69.combineCodec)(
+  return (0, import_kit67.combineCodec)(
     getFinalizeRevealStakeInstructionDataEncoder(),
     getFinalizeRevealStakeInstructionDataDecoder()
   );
@@ -4513,10 +4427,10 @@ async function getFinalizeRevealStakeInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.stakeAccount.value) {
-    accounts.stakeAccount.value = await (0, import_kit69.getProgramDerivedAddress)({
+    accounts.stakeAccount.value = await (0, import_kit67.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        (0, import_kit69.getBytesEncoder)().encode(
+        (0, import_kit67.getBytesEncoder)().encode(
           new Uint8Array([
             115,
             116,
@@ -4533,21 +4447,21 @@ async function getFinalizeRevealStakeInstructionAsync(input, config) {
             116
           ])
         ),
-        (0, import_kit69.getAddressEncoder)().encode(expectAddress(accounts.owner.value)),
-        (0, import_kit69.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit69.getU32Encoder)().encode(expectSome(args.stakeAccountId))
+        (0, import_kit67.getAddressEncoder)().encode(expectAddress(accounts.owner.value)),
+        (0, import_kit67.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit67.getU32Encoder)().encode(expectSome(args.stakeAccountId))
       ]
     });
   }
   if (!accounts.option.value) {
-    accounts.option.value = await (0, import_kit69.getProgramDerivedAddress)({
+    accounts.option.value = await (0, import_kit67.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        (0, import_kit69.getBytesEncoder)().encode(
+        (0, import_kit67.getBytesEncoder)().encode(
           new Uint8Array([111, 112, 116, 105, 111, 110])
         ),
-        (0, import_kit69.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit69.getU64Encoder)().encode(expectSome(args.optionId))
+        (0, import_kit67.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit67.getU64Encoder)().encode(expectSome(args.optionId))
       ]
     });
   }
@@ -4628,7 +4542,7 @@ function parseFinalizeRevealStakeInstruction(instruction) {
 }
 
 // src/generated/instructions/initAllowedMint.ts
-var import_kit70 = require("@solana/kit");
+var import_kit68 = require("@solana/kit");
 var INIT_ALLOWED_MINT_DISCRIMINATOR = new Uint8Array([
   215,
   70,
@@ -4640,23 +4554,23 @@ var INIT_ALLOWED_MINT_DISCRIMINATOR = new Uint8Array([
   10
 ]);
 function getInitAllowedMintDiscriminatorBytes() {
-  return (0, import_kit70.fixEncoderSize)((0, import_kit70.getBytesEncoder)(), 8).encode(
+  return (0, import_kit68.fixEncoderSize)((0, import_kit68.getBytesEncoder)(), 8).encode(
     INIT_ALLOWED_MINT_DISCRIMINATOR
   );
 }
 function getInitAllowedMintInstructionDataEncoder() {
-  return (0, import_kit70.transformEncoder)(
-    (0, import_kit70.getStructEncoder)([["discriminator", (0, import_kit70.fixEncoderSize)((0, import_kit70.getBytesEncoder)(), 8)]]),
+  return (0, import_kit68.transformEncoder)(
+    (0, import_kit68.getStructEncoder)([["discriminator", (0, import_kit68.fixEncoderSize)((0, import_kit68.getBytesEncoder)(), 8)]]),
     (value) => ({ ...value, discriminator: INIT_ALLOWED_MINT_DISCRIMINATOR })
   );
 }
 function getInitAllowedMintInstructionDataDecoder() {
-  return (0, import_kit70.getStructDecoder)([
-    ["discriminator", (0, import_kit70.fixDecoderSize)((0, import_kit70.getBytesDecoder)(), 8)]
+  return (0, import_kit68.getStructDecoder)([
+    ["discriminator", (0, import_kit68.fixDecoderSize)((0, import_kit68.getBytesDecoder)(), 8)]
   ]);
 }
 function getInitAllowedMintInstructionDataCodec() {
-  return (0, import_kit70.combineCodec)(
+  return (0, import_kit68.combineCodec)(
     getInitAllowedMintInstructionDataEncoder(),
     getInitAllowedMintInstructionDataDecoder()
   );
@@ -4672,10 +4586,10 @@ async function getInitAllowedMintInstructionAsync(input, config) {
   };
   const accounts = originalAccounts;
   if (!accounts.allowedMint.value) {
-    accounts.allowedMint.value = await (0, import_kit70.getProgramDerivedAddress)({
+    accounts.allowedMint.value = await (0, import_kit68.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        (0, import_kit70.getBytesEncoder)().encode(
+        (0, import_kit68.getBytesEncoder)().encode(
           new Uint8Array([
             97,
             108,
@@ -4691,10 +4605,10 @@ async function getInitAllowedMintInstructionAsync(input, config) {
             116
           ])
         ),
-        (0, import_kit70.getAddressEncoder)().encode(
+        (0, import_kit68.getAddressEncoder)().encode(
           expectAddress(accounts.platformConfig.value)
         ),
-        (0, import_kit70.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
+        (0, import_kit68.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -4764,7 +4678,7 @@ function parseInitAllowedMintInstruction(instruction) {
 }
 
 // src/generated/instructions/initPlatformConfig.ts
-var import_kit71 = require("@solana/kit");
+var import_kit69 = require("@solana/kit");
 var INIT_PLATFORM_CONFIG_DISCRIMINATOR = new Uint8Array([
   101,
   52,
@@ -4776,43 +4690,43 @@ var INIT_PLATFORM_CONFIG_DISCRIMINATOR = new Uint8Array([
   118
 ]);
 function getInitPlatformConfigDiscriminatorBytes() {
-  return (0, import_kit71.fixEncoderSize)((0, import_kit71.getBytesEncoder)(), 8).encode(
+  return (0, import_kit69.fixEncoderSize)((0, import_kit69.getBytesEncoder)(), 8).encode(
     INIT_PLATFORM_CONFIG_DISCRIMINATOR
   );
 }
 function getInitPlatformConfigInstructionDataEncoder() {
-  return (0, import_kit71.transformEncoder)(
-    (0, import_kit71.getStructEncoder)([
-      ["discriminator", (0, import_kit71.fixEncoderSize)((0, import_kit71.getBytesEncoder)(), 8)],
-      ["name", (0, import_kit71.addEncoderSizePrefix)((0, import_kit71.getUtf8Encoder)(), (0, import_kit71.getU32Encoder)())],
-      ["platformFeeBp", (0, import_kit71.getU16Encoder)()],
-      ["rewardPoolFeeBp", (0, import_kit71.getU16Encoder)()],
-      ["creatorFeeBp", (0, import_kit71.getU16Encoder)()],
-      ["feeClaimAuthority", (0, import_kit71.getAddressEncoder)()],
-      ["minTimeToStakeSeconds", (0, import_kit71.getU64Encoder)()],
-      ["minRevealPeriodSeconds", (0, import_kit71.getU64Encoder)()],
-      ["maxRevealPeriodSeconds", (0, import_kit71.getU64Encoder)()],
-      ["marketResolutionDeadlineSeconds", (0, import_kit71.getU64Encoder)()]
+  return (0, import_kit69.transformEncoder)(
+    (0, import_kit69.getStructEncoder)([
+      ["discriminator", (0, import_kit69.fixEncoderSize)((0, import_kit69.getBytesEncoder)(), 8)],
+      ["name", (0, import_kit69.addEncoderSizePrefix)((0, import_kit69.getUtf8Encoder)(), (0, import_kit69.getU32Encoder)())],
+      ["platformFeeBp", (0, import_kit69.getU16Encoder)()],
+      ["rewardPoolFeeBp", (0, import_kit69.getU16Encoder)()],
+      ["creatorFeeBp", (0, import_kit69.getU16Encoder)()],
+      ["feeClaimAuthority", (0, import_kit69.getAddressEncoder)()],
+      ["revealAuthority", (0, import_kit69.getAddressEncoder)()],
+      ["minTimeToStakeSeconds", (0, import_kit69.getU64Encoder)()],
+      ["revealPeriodSeconds", (0, import_kit69.getU64Encoder)()],
+      ["marketResolutionDeadlineSeconds", (0, import_kit69.getU64Encoder)()]
     ]),
     (value) => ({ ...value, discriminator: INIT_PLATFORM_CONFIG_DISCRIMINATOR })
   );
 }
 function getInitPlatformConfigInstructionDataDecoder() {
-  return (0, import_kit71.getStructDecoder)([
-    ["discriminator", (0, import_kit71.fixDecoderSize)((0, import_kit71.getBytesDecoder)(), 8)],
-    ["name", (0, import_kit71.addDecoderSizePrefix)((0, import_kit71.getUtf8Decoder)(), (0, import_kit71.getU32Decoder)())],
-    ["platformFeeBp", (0, import_kit71.getU16Decoder)()],
-    ["rewardPoolFeeBp", (0, import_kit71.getU16Decoder)()],
-    ["creatorFeeBp", (0, import_kit71.getU16Decoder)()],
-    ["feeClaimAuthority", (0, import_kit71.getAddressDecoder)()],
-    ["minTimeToStakeSeconds", (0, import_kit71.getU64Decoder)()],
-    ["minRevealPeriodSeconds", (0, import_kit71.getU64Decoder)()],
-    ["maxRevealPeriodSeconds", (0, import_kit71.getU64Decoder)()],
-    ["marketResolutionDeadlineSeconds", (0, import_kit71.getU64Decoder)()]
+  return (0, import_kit69.getStructDecoder)([
+    ["discriminator", (0, import_kit69.fixDecoderSize)((0, import_kit69.getBytesDecoder)(), 8)],
+    ["name", (0, import_kit69.addDecoderSizePrefix)((0, import_kit69.getUtf8Decoder)(), (0, import_kit69.getU32Decoder)())],
+    ["platformFeeBp", (0, import_kit69.getU16Decoder)()],
+    ["rewardPoolFeeBp", (0, import_kit69.getU16Decoder)()],
+    ["creatorFeeBp", (0, import_kit69.getU16Decoder)()],
+    ["feeClaimAuthority", (0, import_kit69.getAddressDecoder)()],
+    ["revealAuthority", (0, import_kit69.getAddressDecoder)()],
+    ["minTimeToStakeSeconds", (0, import_kit69.getU64Decoder)()],
+    ["revealPeriodSeconds", (0, import_kit69.getU64Decoder)()],
+    ["marketResolutionDeadlineSeconds", (0, import_kit69.getU64Decoder)()]
   ]);
 }
 function getInitPlatformConfigInstructionDataCodec() {
-  return (0, import_kit71.combineCodec)(
+  return (0, import_kit69.combineCodec)(
     getInitPlatformConfigInstructionDataEncoder(),
     getInitPlatformConfigInstructionDataDecoder()
   );
@@ -4827,10 +4741,10 @@ async function getInitPlatformConfigInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.platformConfig.value) {
-    accounts.platformConfig.value = await (0, import_kit71.getProgramDerivedAddress)({
+    accounts.platformConfig.value = await (0, import_kit69.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        (0, import_kit71.getBytesEncoder)().encode(
+        (0, import_kit69.getBytesEncoder)().encode(
           new Uint8Array([
             112,
             108,
@@ -4849,8 +4763,8 @@ async function getInitPlatformConfigInstructionAsync(input, config) {
             103
           ])
         ),
-        (0, import_kit71.getAddressEncoder)().encode(expectAddress(accounts.payer.value)),
-        (0, import_kit71.getUtf8Encoder)().encode(expectSome(args.name))
+        (0, import_kit69.getAddressEncoder)().encode(expectAddress(accounts.payer.value)),
+        (0, import_kit69.getUtf8Encoder)().encode(expectSome(args.name))
       ]
     });
   }
@@ -4919,7 +4833,7 @@ function parseInitPlatformConfigInstruction(instruction) {
 }
 
 // src/generated/instructions/initStakeAccount.ts
-var import_kit72 = require("@solana/kit");
+var import_kit70 = require("@solana/kit");
 var INIT_STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   132,
   171,
@@ -4931,27 +4845,27 @@ var INIT_STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   45
 ]);
 function getInitStakeAccountDiscriminatorBytes() {
-  return (0, import_kit72.fixEncoderSize)((0, import_kit72.getBytesEncoder)(), 8).encode(
+  return (0, import_kit70.fixEncoderSize)((0, import_kit70.getBytesEncoder)(), 8).encode(
     INIT_STAKE_ACCOUNT_DISCRIMINATOR
   );
 }
 function getInitStakeAccountInstructionDataEncoder() {
-  return (0, import_kit72.transformEncoder)(
-    (0, import_kit72.getStructEncoder)([
-      ["discriminator", (0, import_kit72.fixEncoderSize)((0, import_kit72.getBytesEncoder)(), 8)],
-      ["stakeAccountId", (0, import_kit72.getU32Encoder)()]
+  return (0, import_kit70.transformEncoder)(
+    (0, import_kit70.getStructEncoder)([
+      ["discriminator", (0, import_kit70.fixEncoderSize)((0, import_kit70.getBytesEncoder)(), 8)],
+      ["stakeAccountId", (0, import_kit70.getU32Encoder)()]
     ]),
     (value) => ({ ...value, discriminator: INIT_STAKE_ACCOUNT_DISCRIMINATOR })
   );
 }
 function getInitStakeAccountInstructionDataDecoder() {
-  return (0, import_kit72.getStructDecoder)([
-    ["discriminator", (0, import_kit72.fixDecoderSize)((0, import_kit72.getBytesDecoder)(), 8)],
-    ["stakeAccountId", (0, import_kit72.getU32Decoder)()]
+  return (0, import_kit70.getStructDecoder)([
+    ["discriminator", (0, import_kit70.fixDecoderSize)((0, import_kit70.getBytesDecoder)(), 8)],
+    ["stakeAccountId", (0, import_kit70.getU32Decoder)()]
   ]);
 }
 function getInitStakeAccountInstructionDataCodec() {
-  return (0, import_kit72.combineCodec)(
+  return (0, import_kit70.combineCodec)(
     getInitStakeAccountInstructionDataEncoder(),
     getInitStakeAccountInstructionDataDecoder()
   );
@@ -4968,10 +4882,10 @@ async function getInitStakeAccountInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.stakeAccount.value) {
-    accounts.stakeAccount.value = await (0, import_kit72.getProgramDerivedAddress)({
+    accounts.stakeAccount.value = await (0, import_kit70.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        (0, import_kit72.getBytesEncoder)().encode(
+        (0, import_kit70.getBytesEncoder)().encode(
           new Uint8Array([
             115,
             116,
@@ -4988,9 +4902,9 @@ async function getInitStakeAccountInstructionAsync(input, config) {
             116
           ])
         ),
-        (0, import_kit72.getAddressEncoder)().encode(expectAddress(accounts.owner.value)),
-        (0, import_kit72.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit72.getU32Encoder)().encode(expectSome(args.stakeAccountId))
+        (0, import_kit70.getAddressEncoder)().encode(expectAddress(accounts.owner.value)),
+        (0, import_kit70.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit70.getU32Encoder)().encode(expectSome(args.stakeAccountId))
       ]
     });
   }
@@ -5065,7 +4979,7 @@ function parseInitStakeAccountInstruction(instruction) {
 }
 
 // src/generated/instructions/openMarket.ts
-var import_kit73 = require("@solana/kit");
+var import_kit71 = require("@solana/kit");
 var OPEN_MARKET_DISCRIMINATOR = new Uint8Array([
   116,
   19,
@@ -5077,25 +4991,25 @@ var OPEN_MARKET_DISCRIMINATOR = new Uint8Array([
   44
 ]);
 function getOpenMarketDiscriminatorBytes() {
-  return (0, import_kit73.fixEncoderSize)((0, import_kit73.getBytesEncoder)(), 8).encode(OPEN_MARKET_DISCRIMINATOR);
+  return (0, import_kit71.fixEncoderSize)((0, import_kit71.getBytesEncoder)(), 8).encode(OPEN_MARKET_DISCRIMINATOR);
 }
 function getOpenMarketInstructionDataEncoder() {
-  return (0, import_kit73.transformEncoder)(
-    (0, import_kit73.getStructEncoder)([
-      ["discriminator", (0, import_kit73.fixEncoderSize)((0, import_kit73.getBytesEncoder)(), 8)],
-      ["timeToStake", (0, import_kit73.getU64Encoder)()]
+  return (0, import_kit71.transformEncoder)(
+    (0, import_kit71.getStructEncoder)([
+      ["discriminator", (0, import_kit71.fixEncoderSize)((0, import_kit71.getBytesEncoder)(), 8)],
+      ["timeToStake", (0, import_kit71.getU64Encoder)()]
     ]),
     (value) => ({ ...value, discriminator: OPEN_MARKET_DISCRIMINATOR })
   );
 }
 function getOpenMarketInstructionDataDecoder() {
-  return (0, import_kit73.getStructDecoder)([
-    ["discriminator", (0, import_kit73.fixDecoderSize)((0, import_kit73.getBytesDecoder)(), 8)],
-    ["timeToStake", (0, import_kit73.getU64Decoder)()]
+  return (0, import_kit71.getStructDecoder)([
+    ["discriminator", (0, import_kit71.fixDecoderSize)((0, import_kit71.getBytesDecoder)(), 8)],
+    ["timeToStake", (0, import_kit71.getU64Decoder)()]
   ]);
 }
 function getOpenMarketInstructionDataCodec() {
-  return (0, import_kit73.combineCodec)(
+  return (0, import_kit71.combineCodec)(
     getOpenMarketInstructionDataEncoder(),
     getOpenMarketInstructionDataDecoder()
   );
@@ -5146,79 +5060,8 @@ function parseOpenMarketInstruction(instruction) {
   };
 }
 
-// src/generated/instructions/pauseStaking.ts
-var import_kit74 = require("@solana/kit");
-var PAUSE_STAKING_DISCRIMINATOR = new Uint8Array([
-  245,
-  191,
-  35,
-  58,
-  88,
-  250,
-  229,
-  60
-]);
-function getPauseStakingDiscriminatorBytes() {
-  return (0, import_kit74.fixEncoderSize)((0, import_kit74.getBytesEncoder)(), 8).encode(
-    PAUSE_STAKING_DISCRIMINATOR
-  );
-}
-function getPauseStakingInstructionDataEncoder() {
-  return (0, import_kit74.transformEncoder)(
-    (0, import_kit74.getStructEncoder)([["discriminator", (0, import_kit74.fixEncoderSize)((0, import_kit74.getBytesEncoder)(), 8)]]),
-    (value) => ({ ...value, discriminator: PAUSE_STAKING_DISCRIMINATOR })
-  );
-}
-function getPauseStakingInstructionDataDecoder() {
-  return (0, import_kit74.getStructDecoder)([
-    ["discriminator", (0, import_kit74.fixDecoderSize)((0, import_kit74.getBytesDecoder)(), 8)]
-  ]);
-}
-function getPauseStakingInstructionDataCodec() {
-  return (0, import_kit74.combineCodec)(
-    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
-var import_kit75 = require("@solana/kit");
+var import_kit72 = require("@solana/kit");
 var RESOLVE_MARKET_DISCRIMINATOR = new Uint8Array([
   155,
   23,
@@ -5230,23 +5073,23 @@ var RESOLVE_MARKET_DISCRIMINATOR = new Uint8Array([
   239
 ]);
 function getResolveMarketDiscriminatorBytes() {
-  return (0, import_kit75.fixEncoderSize)((0, import_kit75.getBytesEncoder)(), 8).encode(
+  return (0, import_kit72.fixEncoderSize)((0, import_kit72.getBytesEncoder)(), 8).encode(
     RESOLVE_MARKET_DISCRIMINATOR
   );
 }
 function getResolveMarketInstructionDataEncoder() {
-  return (0, import_kit75.transformEncoder)(
-    (0, import_kit75.getStructEncoder)([["discriminator", (0, import_kit75.fixEncoderSize)((0, import_kit75.getBytesEncoder)(), 8)]]),
+  return (0, import_kit72.transformEncoder)(
+    (0, import_kit72.getStructEncoder)([["discriminator", (0, import_kit72.fixEncoderSize)((0, import_kit72.getBytesEncoder)(), 8)]]),
     (value) => ({ ...value, discriminator: RESOLVE_MARKET_DISCRIMINATOR })
   );
 }
 function getResolveMarketInstructionDataDecoder() {
-  return (0, import_kit75.getStructDecoder)([
-    ["discriminator", (0, import_kit75.fixDecoderSize)((0, import_kit75.getBytesDecoder)(), 8)]
+  return (0, import_kit72.getStructDecoder)([
+    ["discriminator", (0, import_kit72.fixDecoderSize)((0, import_kit72.getBytesDecoder)(), 8)]
   ]);
 }
 function getResolveMarketInstructionDataCodec() {
-  return (0, import_kit75.combineCodec)(
+  return (0, import_kit72.combineCodec)(
     getResolveMarketInstructionDataEncoder(),
     getResolveMarketInstructionDataDecoder()
   );
@@ -5288,79 +5131,8 @@ function parseResolveMarketInstruction(instruction) {
   };
 }
 
-// src/generated/instructions/resumeStaking.ts
-var import_kit76 = require("@solana/kit");
-var RESUME_STAKING_DISCRIMINATOR = new Uint8Array([
-  31,
-  200,
-  175,
-  23,
-  211,
-  22,
-  63,
-  155
-]);
-function getResumeStakingDiscriminatorBytes() {
-  return (0, import_kit76.fixEncoderSize)((0, import_kit76.getBytesEncoder)(), 8).encode(
-    RESUME_STAKING_DISCRIMINATOR
-  );
-}
-function getResumeStakingInstructionDataEncoder() {
-  return (0, import_kit76.transformEncoder)(
-    (0, import_kit76.getStructEncoder)([["discriminator", (0, import_kit76.fixEncoderSize)((0, import_kit76.getBytesEncoder)(), 8)]]),
-    (value) => ({ ...value, discriminator: RESUME_STAKING_DISCRIMINATOR })
-  );
-}
-function getResumeStakingInstructionDataDecoder() {
-  return (0, import_kit76.getStructDecoder)([
-    ["discriminator", (0, import_kit76.fixDecoderSize)((0, import_kit76.getBytesDecoder)(), 8)]
-  ]);
-}
-function getResumeStakingInstructionDataCodec() {
-  return (0, import_kit76.combineCodec)(
-    getResumeStakingInstructionDataEncoder(),
-    getResumeStakingInstructionDataDecoder()
-  );
-}
-function getResumeStakingInstruction(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: getResumeStakingInstructionDataEncoder().encode({}),
-    programAddress
-  });
-}
-function parseResumeStakingInstruction(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: getResumeStakingInstructionDataDecoder().decode(instruction.data)
-  };
-}
-
 // src/generated/instructions/revealStake.ts
-var import_kit77 = require("@solana/kit");
+var import_kit73 = require("@solana/kit");
 var REVEAL_STAKE_DISCRIMINATOR = new Uint8Array([
   107,
   229,
@@ -5372,29 +5144,29 @@ var REVEAL_STAKE_DISCRIMINATOR = new Uint8Array([
   188
 ]);
 function getRevealStakeDiscriminatorBytes() {
-  return (0, import_kit77.fixEncoderSize)((0, import_kit77.getBytesEncoder)(), 8).encode(
+  return (0, import_kit73.fixEncoderSize)((0, import_kit73.getBytesEncoder)(), 8).encode(
     REVEAL_STAKE_DISCRIMINATOR
   );
 }
 function getRevealStakeInstructionDataEncoder() {
-  return (0, import_kit77.transformEncoder)(
-    (0, import_kit77.getStructEncoder)([
-      ["discriminator", (0, import_kit77.fixEncoderSize)((0, import_kit77.getBytesEncoder)(), 8)],
-      ["computationOffset", (0, import_kit77.getU64Encoder)()],
-      ["stakeAccountId", (0, import_kit77.getU32Encoder)()]
+  return (0, import_kit73.transformEncoder)(
+    (0, import_kit73.getStructEncoder)([
+      ["discriminator", (0, import_kit73.fixEncoderSize)((0, import_kit73.getBytesEncoder)(), 8)],
+      ["computationOffset", (0, import_kit73.getU64Encoder)()],
+      ["stakeAccountId", (0, import_kit73.getU32Encoder)()]
     ]),
     (value) => ({ ...value, discriminator: REVEAL_STAKE_DISCRIMINATOR })
   );
 }
 function getRevealStakeInstructionDataDecoder() {
-  return (0, import_kit77.getStructDecoder)([
-    ["discriminator", (0, import_kit77.fixDecoderSize)((0, import_kit77.getBytesDecoder)(), 8)],
-    ["computationOffset", (0, import_kit77.getU64Decoder)()],
-    ["stakeAccountId", (0, import_kit77.getU32Decoder)()]
+  return (0, import_kit73.getStructDecoder)([
+    ["discriminator", (0, import_kit73.fixDecoderSize)((0, import_kit73.getBytesDecoder)(), 8)],
+    ["computationOffset", (0, import_kit73.getU64Decoder)()],
+    ["stakeAccountId", (0, import_kit73.getU32Decoder)()]
   ]);
 }
 function getRevealStakeInstructionDataCodec() {
-  return (0, import_kit77.combineCodec)(
+  return (0, import_kit73.combineCodec)(
     getRevealStakeInstructionDataEncoder(),
     getRevealStakeInstructionDataDecoder()
   );
@@ -5424,10 +5196,10 @@ async function getRevealStakeInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.stakeAccount.value) {
-    accounts.stakeAccount.value = await (0, import_kit77.getProgramDerivedAddress)({
+    accounts.stakeAccount.value = await (0, import_kit73.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        (0, import_kit77.getBytesEncoder)().encode(
+        (0, import_kit73.getBytesEncoder)().encode(
           new Uint8Array([
             115,
             116,
@@ -5444,17 +5216,17 @@ async function getRevealStakeInstructionAsync(input, config) {
             116
           ])
         ),
-        (0, import_kit77.getAddressEncoder)().encode(expectAddress(accounts.owner.value)),
-        (0, import_kit77.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit77.getU32Encoder)().encode(expectSome(args.stakeAccountId))
+        (0, import_kit73.getAddressEncoder)().encode(expectAddress(accounts.owner.value)),
+        (0, import_kit73.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit73.getU32Encoder)().encode(expectSome(args.stakeAccountId))
       ]
     });
   }
   if (!accounts.signPdaAccount.value) {
-    accounts.signPdaAccount.value = await (0, import_kit77.getProgramDerivedAddress)({
+    accounts.signPdaAccount.value = await (0, import_kit73.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        (0, import_kit77.getBytesEncoder)().encode(
+        (0, import_kit73.getBytesEncoder)().encode(
           new Uint8Array([
             65,
             114,
@@ -5612,7 +5384,7 @@ function parseRevealStakeInstruction(instruction) {
 }
 
 // src/generated/instructions/revealStakeCallback.ts
-var import_kit78 = require("@solana/kit");
+var import_kit74 = require("@solana/kit");
 var REVEAL_STAKE_CALLBACK_DISCRIMINATOR = new Uint8Array([
   79,
   19,
@@ -5624,34 +5396,34 @@ var REVEAL_STAKE_CALLBACK_DISCRIMINATOR = new Uint8Array([
   116
 ]);
 function getRevealStakeCallbackDiscriminatorBytes() {
-  return (0, import_kit78.fixEncoderSize)((0, import_kit78.getBytesEncoder)(), 8).encode(
+  return (0, import_kit74.fixEncoderSize)((0, import_kit74.getBytesEncoder)(), 8).encode(
     REVEAL_STAKE_CALLBACK_DISCRIMINATOR
   );
 }
 function getRevealStakeCallbackInstructionDataEncoder() {
-  return (0, import_kit78.transformEncoder)(
-    (0, import_kit78.getStructEncoder)([
-      ["discriminator", (0, import_kit78.fixEncoderSize)((0, import_kit78.getBytesEncoder)(), 8)],
+  return (0, import_kit74.transformEncoder)(
+    (0, import_kit74.getStructEncoder)([
+      ["discriminator", (0, import_kit74.fixEncoderSize)((0, import_kit74.getBytesEncoder)(), 8)],
       [
         "output",
-        (0, import_kit78.getDiscriminatedUnionEncoder)([
+        (0, import_kit74.getDiscriminatedUnionEncoder)([
           [
             "Success",
-            (0, import_kit78.getStructEncoder)([
+            (0, import_kit74.getStructEncoder)([
               [
                 "fields",
-                (0, import_kit78.getTupleEncoder)([
+                (0, import_kit74.getTupleEncoder)([
                   getRevealStakeOutputEncoder(),
-                  (0, import_kit78.getArrayEncoder)((0, import_kit78.getU8Encoder)(), { size: 64 })
+                  (0, import_kit74.getArrayEncoder)((0, import_kit74.getU8Encoder)(), { size: 64 })
                 ])
               ]
             ])
           ],
-          ["Failure", (0, import_kit78.getUnitEncoder)()],
+          ["Failure", (0, import_kit74.getUnitEncoder)()],
           [
             "MarkerForIdlBuildDoNotUseThis",
-            (0, import_kit78.getStructEncoder)([
-              ["fields", (0, import_kit78.getTupleEncoder)([getRevealStakeOutputEncoder()])]
+            (0, import_kit74.getStructEncoder)([
+              ["fields", (0, import_kit74.getTupleEncoder)([getRevealStakeOutputEncoder()])]
             ])
           ]
         ])
@@ -5664,28 +5436,28 @@ function getRevealStakeCallbackInstructionDataEncoder() {
   );
 }
 function getRevealStakeCallbackInstructionDataDecoder() {
-  return (0, import_kit78.getStructDecoder)([
-    ["discriminator", (0, import_kit78.fixDecoderSize)((0, import_kit78.getBytesDecoder)(), 8)],
+  return (0, import_kit74.getStructDecoder)([
+    ["discriminator", (0, import_kit74.fixDecoderSize)((0, import_kit74.getBytesDecoder)(), 8)],
     [
       "output",
-      (0, import_kit78.getDiscriminatedUnionDecoder)([
+      (0, import_kit74.getDiscriminatedUnionDecoder)([
         [
           "Success",
-          (0, import_kit78.getStructDecoder)([
+          (0, import_kit74.getStructDecoder)([
             [
               "fields",
-              (0, import_kit78.getTupleDecoder)([
+              (0, import_kit74.getTupleDecoder)([
                 getRevealStakeOutputDecoder(),
-                (0, import_kit78.getArrayDecoder)((0, import_kit78.getU8Decoder)(), { size: 64 })
+                (0, import_kit74.getArrayDecoder)((0, import_kit74.getU8Decoder)(), { size: 64 })
               ])
             ]
           ])
         ],
-        ["Failure", (0, import_kit78.getUnitDecoder)()],
+        ["Failure", (0, import_kit74.getUnitDecoder)()],
         [
           "MarkerForIdlBuildDoNotUseThis",
-          (0, import_kit78.getStructDecoder)([
-            ["fields", (0, import_kit78.getTupleDecoder)([getRevealStakeOutputDecoder()])]
+          (0, import_kit74.getStructDecoder)([
+            ["fields", (0, import_kit74.getTupleDecoder)([getRevealStakeOutputDecoder()])]
           ])
         ]
       ])
@@ -5693,7 +5465,7 @@ function getRevealStakeCallbackInstructionDataDecoder() {
   ]);
 }
 function getRevealStakeCallbackInstructionDataCodec() {
-  return (0, import_kit78.combineCodec)(
+  return (0, import_kit74.combineCodec)(
     getRevealStakeCallbackInstructionDataEncoder(),
     getRevealStakeCallbackInstructionDataDecoder()
   );
@@ -5768,7 +5540,7 @@ function parseRevealStakeCallbackInstruction(instruction) {
 }
 
 // src/generated/instructions/revealStakeCompDef.ts
-var import_kit79 = require("@solana/kit");
+var import_kit75 = require("@solana/kit");
 var REVEAL_STAKE_COMP_DEF_DISCRIMINATOR = new Uint8Array([
   197,
   20,
@@ -5780,13 +5552,13 @@ var REVEAL_STAKE_COMP_DEF_DISCRIMINATOR = new Uint8Array([
   0
 ]);
 function getRevealStakeCompDefDiscriminatorBytes() {
-  return (0, import_kit79.fixEncoderSize)((0, import_kit79.getBytesEncoder)(), 8).encode(
+  return (0, import_kit75.fixEncoderSize)((0, import_kit75.getBytesEncoder)(), 8).encode(
     REVEAL_STAKE_COMP_DEF_DISCRIMINATOR
   );
 }
 function getRevealStakeCompDefInstructionDataEncoder() {
-  return (0, import_kit79.transformEncoder)(
-    (0, import_kit79.getStructEncoder)([["discriminator", (0, import_kit79.fixEncoderSize)((0, import_kit79.getBytesEncoder)(), 8)]]),
+  return (0, import_kit75.transformEncoder)(
+    (0, import_kit75.getStructEncoder)([["discriminator", (0, import_kit75.fixEncoderSize)((0, import_kit75.getBytesEncoder)(), 8)]]),
     (value) => ({
       ...value,
       discriminator: REVEAL_STAKE_COMP_DEF_DISCRIMINATOR
@@ -5794,12 +5566,12 @@ function getRevealStakeCompDefInstructionDataEncoder() {
   );
 }
 function getRevealStakeCompDefInstructionDataDecoder() {
-  return (0, import_kit79.getStructDecoder)([
-    ["discriminator", (0, import_kit79.fixDecoderSize)((0, import_kit79.getBytesDecoder)(), 8)]
+  return (0, import_kit75.getStructDecoder)([
+    ["discriminator", (0, import_kit75.fixDecoderSize)((0, import_kit75.getBytesDecoder)(), 8)]
   ]);
 }
 function getRevealStakeCompDefInstructionDataCodec() {
-  return (0, import_kit79.combineCodec)(
+  return (0, import_kit75.combineCodec)(
     getRevealStakeCompDefInstructionDataEncoder(),
     getRevealStakeCompDefInstructionDataDecoder()
   );
@@ -5871,7 +5643,7 @@ function parseRevealStakeCompDefInstruction(instruction) {
 }
 
 // src/generated/instructions/setFeeClaimAuthority.ts
-var import_kit80 = require("@solana/kit");
+var import_kit76 = require("@solana/kit");
 var SET_FEE_CLAIM_AUTHORITY_DISCRIMINATOR = new Uint8Array([
   75,
   250,
@@ -5883,13 +5655,13 @@ var SET_FEE_CLAIM_AUTHORITY_DISCRIMINATOR = new Uint8Array([
   3
 ]);
 function getSetFeeClaimAuthorityDiscriminatorBytes() {
-  return (0, import_kit80.fixEncoderSize)((0, import_kit80.getBytesEncoder)(), 8).encode(
+  return (0, import_kit76.fixEncoderSize)((0, import_kit76.getBytesEncoder)(), 8).encode(
     SET_FEE_CLAIM_AUTHORITY_DISCRIMINATOR
   );
 }
 function getSetFeeClaimAuthorityInstructionDataEncoder() {
-  return (0, import_kit80.transformEncoder)(
-    (0, import_kit80.getStructEncoder)([["discriminator", (0, import_kit80.fixEncoderSize)((0, import_kit80.getBytesEncoder)(), 8)]]),
+  return (0, import_kit76.transformEncoder)(
+    (0, import_kit76.getStructEncoder)([["discriminator", (0, import_kit76.fixEncoderSize)((0, import_kit76.getBytesEncoder)(), 8)]]),
     (value) => ({
       ...value,
       discriminator: SET_FEE_CLAIM_AUTHORITY_DISCRIMINATOR
@@ -5897,12 +5669,12 @@ function getSetFeeClaimAuthorityInstructionDataEncoder() {
   );
 }
 function getSetFeeClaimAuthorityInstructionDataDecoder() {
-  return (0, import_kit80.getStructDecoder)([
-    ["discriminator", (0, import_kit80.fixDecoderSize)((0, import_kit80.getBytesDecoder)(), 8)]
+  return (0, import_kit76.getStructDecoder)([
+    ["discriminator", (0, import_kit76.fixDecoderSize)((0, import_kit76.getBytesDecoder)(), 8)]
   ]);
 }
 function getSetFeeClaimAuthorityInstructionDataCodec() {
-  return (0, import_kit80.combineCodec)(
+  return (0, import_kit76.combineCodec)(
     getSetFeeClaimAuthorityInstructionDataEncoder(),
     getSetFeeClaimAuthorityInstructionDataDecoder()
   );
@@ -5956,7 +5728,7 @@ function parseSetFeeClaimAuthorityInstruction(instruction) {
 }
 
 // src/generated/instructions/setUpdateAuthority.ts
-var import_kit81 = require("@solana/kit");
+var import_kit77 = require("@solana/kit");
 var SET_UPDATE_AUTHORITY_DISCRIMINATOR = new Uint8Array([
   166,
   198,
@@ -5968,23 +5740,23 @@ var SET_UPDATE_AUTHORITY_DISCRIMINATOR = new Uint8Array([
   155
 ]);
 function getSetUpdateAuthorityDiscriminatorBytes() {
-  return (0, import_kit81.fixEncoderSize)((0, import_kit81.getBytesEncoder)(), 8).encode(
+  return (0, import_kit77.fixEncoderSize)((0, import_kit77.getBytesEncoder)(), 8).encode(
     SET_UPDATE_AUTHORITY_DISCRIMINATOR
   );
 }
 function getSetUpdateAuthorityInstructionDataEncoder() {
-  return (0, import_kit81.transformEncoder)(
-    (0, import_kit81.getStructEncoder)([["discriminator", (0, import_kit81.fixEncoderSize)((0, import_kit81.getBytesEncoder)(), 8)]]),
+  return (0, import_kit77.transformEncoder)(
+    (0, import_kit77.getStructEncoder)([["discriminator", (0, import_kit77.fixEncoderSize)((0, import_kit77.getBytesEncoder)(), 8)]]),
     (value) => ({ ...value, discriminator: SET_UPDATE_AUTHORITY_DISCRIMINATOR })
   );
 }
 function getSetUpdateAuthorityInstructionDataDecoder() {
-  return (0, import_kit81.getStructDecoder)([
-    ["discriminator", (0, import_kit81.fixDecoderSize)((0, import_kit81.getBytesDecoder)(), 8)]
+  return (0, import_kit77.getStructDecoder)([
+    ["discriminator", (0, import_kit77.fixDecoderSize)((0, import_kit77.getBytesDecoder)(), 8)]
   ]);
 }
 function getSetUpdateAuthorityInstructionDataCodec() {
-  return (0, import_kit81.combineCodec)(
+  return (0, import_kit77.combineCodec)(
     getSetUpdateAuthorityInstructionDataEncoder(),
     getSetUpdateAuthorityInstructionDataDecoder()
   );
@@ -6035,7 +5807,7 @@ function parseSetUpdateAuthorityInstruction(instruction) {
 }
 
 // src/generated/instructions/setWinningOption.ts
-var import_kit82 = require("@solana/kit");
+var import_kit78 = require("@solana/kit");
 var SET_WINNING_OPTION_DISCRIMINATOR = new Uint8Array([
   156,
   73,
@@ -6047,29 +5819,29 @@ var SET_WINNING_OPTION_DISCRIMINATOR = new Uint8Array([
   206
 ]);
 function getSetWinningOptionDiscriminatorBytes() {
-  return (0, import_kit82.fixEncoderSize)((0, import_kit82.getBytesEncoder)(), 8).encode(
+  return (0, import_kit78.fixEncoderSize)((0, import_kit78.getBytesEncoder)(), 8).encode(
     SET_WINNING_OPTION_DISCRIMINATOR
   );
 }
 function getSetWinningOptionInstructionDataEncoder() {
-  return (0, import_kit82.transformEncoder)(
-    (0, import_kit82.getStructEncoder)([
-      ["discriminator", (0, import_kit82.fixEncoderSize)((0, import_kit82.getBytesEncoder)(), 8)],
-      ["optionId", (0, import_kit82.getU64Encoder)()],
-      ["rewardBp", (0, import_kit82.getU16Encoder)()]
+  return (0, import_kit78.transformEncoder)(
+    (0, import_kit78.getStructEncoder)([
+      ["discriminator", (0, import_kit78.fixEncoderSize)((0, import_kit78.getBytesEncoder)(), 8)],
+      ["optionId", (0, import_kit78.getU64Encoder)()],
+      ["rewardBp", (0, import_kit78.getU16Encoder)()]
     ]),
     (value) => ({ ...value, discriminator: SET_WINNING_OPTION_DISCRIMINATOR })
   );
 }
 function getSetWinningOptionInstructionDataDecoder() {
-  return (0, import_kit82.getStructDecoder)([
-    ["discriminator", (0, import_kit82.fixDecoderSize)((0, import_kit82.getBytesDecoder)(), 8)],
-    ["optionId", (0, import_kit82.getU64Decoder)()],
-    ["rewardBp", (0, import_kit82.getU16Decoder)()]
+  return (0, import_kit78.getStructDecoder)([
+    ["discriminator", (0, import_kit78.fixDecoderSize)((0, import_kit78.getBytesDecoder)(), 8)],
+    ["optionId", (0, import_kit78.getU64Decoder)()],
+    ["rewardBp", (0, import_kit78.getU16Decoder)()]
   ]);
 }
 function getSetWinningOptionInstructionDataCodec() {
-  return (0, import_kit82.combineCodec)(
+  return (0, import_kit78.combineCodec)(
     getSetWinningOptionInstructionDataEncoder(),
     getSetWinningOptionInstructionDataDecoder()
   );
@@ -6087,14 +5859,14 @@ async function getSetWinningOptionInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.option.value) {
-    accounts.option.value = await (0, import_kit82.getProgramDerivedAddress)({
+    accounts.option.value = await (0, import_kit78.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        (0, import_kit82.getBytesEncoder)().encode(
+        (0, import_kit78.getBytesEncoder)().encode(
           new Uint8Array([111, 112, 116, 105, 111, 110])
         ),
-        (0, import_kit82.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit82.getU64Encoder)().encode(expectSome(args.optionId))
+        (0, import_kit78.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit78.getU64Encoder)().encode(expectSome(args.optionId))
       ]
     });
   }
@@ -6158,7 +5930,7 @@ function parseSetWinningOptionInstruction(instruction) {
 }
 
 // src/generated/instructions/stake.ts
-var import_kit83 = require("@solana/kit");
+var import_kit79 = require("@solana/kit");
 var STAKE_DISCRIMINATOR = new Uint8Array([
   206,
   176,
@@ -6170,42 +5942,42 @@ var STAKE_DISCRIMINATOR = new Uint8Array([
   108
 ]);
 function getStakeDiscriminatorBytes() {
-  return (0, import_kit83.fixEncoderSize)((0, import_kit83.getBytesEncoder)(), 8).encode(STAKE_DISCRIMINATOR);
+  return (0, import_kit79.fixEncoderSize)((0, import_kit79.getBytesEncoder)(), 8).encode(STAKE_DISCRIMINATOR);
 }
 function getStakeInstructionDataEncoder() {
-  return (0, import_kit83.transformEncoder)(
-    (0, import_kit83.getStructEncoder)([
-      ["discriminator", (0, import_kit83.fixEncoderSize)((0, import_kit83.getBytesEncoder)(), 8)],
-      ["computationOffset", (0, import_kit83.getU64Encoder)()],
-      ["stakeAccountId", (0, import_kit83.getU32Encoder)()],
-      ["amount", (0, import_kit83.getU64Encoder)()],
+  return (0, import_kit79.transformEncoder)(
+    (0, import_kit79.getStructEncoder)([
+      ["discriminator", (0, import_kit79.fixEncoderSize)((0, import_kit79.getBytesEncoder)(), 8)],
+      ["computationOffset", (0, import_kit79.getU64Encoder)()],
+      ["stakeAccountId", (0, import_kit79.getU32Encoder)()],
+      ["amount", (0, import_kit79.getU64Encoder)()],
       [
         "selectedOptionCiphertext",
-        (0, import_kit83.getArrayEncoder)((0, import_kit83.getU8Encoder)(), { size: 32 })
+        (0, import_kit79.getArrayEncoder)((0, import_kit79.getU8Encoder)(), { size: 32 })
       ],
-      ["inputNonce", (0, import_kit83.getU128Encoder)()],
-      ["authorizedReaderNonce", (0, import_kit83.getU128Encoder)()],
-      ["userPubkey", (0, import_kit83.getArrayEncoder)((0, import_kit83.getU8Encoder)(), { size: 32 })],
-      ["stateNonce", (0, import_kit83.getU128Encoder)()]
+      ["inputNonce", (0, import_kit79.getU128Encoder)()],
+      ["authorizedReaderNonce", (0, import_kit79.getU128Encoder)()],
+      ["userPubkey", (0, import_kit79.getArrayEncoder)((0, import_kit79.getU8Encoder)(), { size: 32 })],
+      ["stateNonce", (0, import_kit79.getU128Encoder)()]
     ]),
     (value) => ({ ...value, discriminator: STAKE_DISCRIMINATOR })
   );
 }
 function getStakeInstructionDataDecoder() {
-  return (0, import_kit83.getStructDecoder)([
-    ["discriminator", (0, import_kit83.fixDecoderSize)((0, import_kit83.getBytesDecoder)(), 8)],
-    ["computationOffset", (0, import_kit83.getU64Decoder)()],
-    ["stakeAccountId", (0, import_kit83.getU32Decoder)()],
-    ["amount", (0, import_kit83.getU64Decoder)()],
-    ["selectedOptionCiphertext", (0, import_kit83.getArrayDecoder)((0, import_kit83.getU8Decoder)(), { size: 32 })],
-    ["inputNonce", (0, import_kit83.getU128Decoder)()],
-    ["authorizedReaderNonce", (0, import_kit83.getU128Decoder)()],
-    ["userPubkey", (0, import_kit83.getArrayDecoder)((0, import_kit83.getU8Decoder)(), { size: 32 })],
-    ["stateNonce", (0, import_kit83.getU128Decoder)()]
+  return (0, import_kit79.getStructDecoder)([
+    ["discriminator", (0, import_kit79.fixDecoderSize)((0, import_kit79.getBytesDecoder)(), 8)],
+    ["computationOffset", (0, import_kit79.getU64Decoder)()],
+    ["stakeAccountId", (0, import_kit79.getU32Decoder)()],
+    ["amount", (0, import_kit79.getU64Decoder)()],
+    ["selectedOptionCiphertext", (0, import_kit79.getArrayDecoder)((0, import_kit79.getU8Decoder)(), { size: 32 })],
+    ["inputNonce", (0, import_kit79.getU128Decoder)()],
+    ["authorizedReaderNonce", (0, import_kit79.getU128Decoder)()],
+    ["userPubkey", (0, import_kit79.getArrayDecoder)((0, import_kit79.getU8Decoder)(), { size: 32 })],
+    ["stateNonce", (0, import_kit79.getU128Decoder)()]
   ]);
 }
 function getStakeInstructionDataCodec() {
-  return (0, import_kit83.combineCodec)(
+  return (0, import_kit79.combineCodec)(
     getStakeInstructionDataEncoder(),
     getStakeInstructionDataDecoder()
   );
@@ -6242,20 +6014,20 @@ async function getStakeInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.marketTokenAta.value) {
-    accounts.marketTokenAta.value = await (0, import_kit83.getProgramDerivedAddress)({
+    accounts.marketTokenAta.value = await (0, import_kit79.getProgramDerivedAddress)({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        (0, import_kit83.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit83.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
-        (0, import_kit83.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
+        (0, import_kit79.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit79.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
+        (0, import_kit79.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
   if (!accounts.signPdaAccount.value) {
-    accounts.signPdaAccount.value = await (0, import_kit83.getProgramDerivedAddress)({
+    accounts.signPdaAccount.value = await (0, import_kit79.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        (0, import_kit83.getBytesEncoder)().encode(
+        (0, import_kit79.getBytesEncoder)().encode(
           new Uint8Array([
             65,
             114,
@@ -6432,7 +6204,7 @@ function parseStakeInstruction(instruction) {
 }
 
 // src/generated/instructions/stakeCallback.ts
-var import_kit84 = require("@solana/kit");
+var import_kit80 = require("@solana/kit");
 var STAKE_CALLBACK_DISCRIMINATOR = new Uint8Array([
   40,
   220,
@@ -6444,34 +6216,34 @@ var STAKE_CALLBACK_DISCRIMINATOR = new Uint8Array([
   89
 ]);
 function getStakeCallbackDiscriminatorBytes() {
-  return (0, import_kit84.fixEncoderSize)((0, import_kit84.getBytesEncoder)(), 8).encode(
+  return (0, import_kit80.fixEncoderSize)((0, import_kit80.getBytesEncoder)(), 8).encode(
     STAKE_CALLBACK_DISCRIMINATOR
   );
 }
 function getStakeCallbackInstructionDataEncoder() {
-  return (0, import_kit84.transformEncoder)(
-    (0, import_kit84.getStructEncoder)([
-      ["discriminator", (0, import_kit84.fixEncoderSize)((0, import_kit84.getBytesEncoder)(), 8)],
+  return (0, import_kit80.transformEncoder)(
+    (0, import_kit80.getStructEncoder)([
+      ["discriminator", (0, import_kit80.fixEncoderSize)((0, import_kit80.getBytesEncoder)(), 8)],
       [
         "output",
-        (0, import_kit84.getDiscriminatedUnionEncoder)([
+        (0, import_kit80.getDiscriminatedUnionEncoder)([
           [
             "Success",
-            (0, import_kit84.getStructEncoder)([
+            (0, import_kit80.getStructEncoder)([
               [
                 "fields",
-                (0, import_kit84.getTupleEncoder)([
+                (0, import_kit80.getTupleEncoder)([
                   getStakeOutputEncoder(),
-                  (0, import_kit84.getArrayEncoder)((0, import_kit84.getU8Encoder)(), { size: 64 })
+                  (0, import_kit80.getArrayEncoder)((0, import_kit80.getU8Encoder)(), { size: 64 })
                 ])
               ]
             ])
           ],
-          ["Failure", (0, import_kit84.getUnitEncoder)()],
+          ["Failure", (0, import_kit80.getUnitEncoder)()],
           [
             "MarkerForIdlBuildDoNotUseThis",
-            (0, import_kit84.getStructEncoder)([
-              ["fields", (0, import_kit84.getTupleEncoder)([getStakeOutputEncoder()])]
+            (0, import_kit80.getStructEncoder)([
+              ["fields", (0, import_kit80.getTupleEncoder)([getStakeOutputEncoder()])]
             ])
           ]
         ])
@@ -6481,28 +6253,28 @@ function getStakeCallbackInstructionDataEncoder() {
   );
 }
 function getStakeCallbackInstructionDataDecoder() {
-  return (0, import_kit84.getStructDecoder)([
-    ["discriminator", (0, import_kit84.fixDecoderSize)((0, import_kit84.getBytesDecoder)(), 8)],
+  return (0, import_kit80.getStructDecoder)([
+    ["discriminator", (0, import_kit80.fixDecoderSize)((0, import_kit80.getBytesDecoder)(), 8)],
     [
       "output",
-      (0, import_kit84.getDiscriminatedUnionDecoder)([
+      (0, import_kit80.getDiscriminatedUnionDecoder)([
         [
           "Success",
-          (0, import_kit84.getStructDecoder)([
+          (0, import_kit80.getStructDecoder)([
             [
               "fields",
-              (0, import_kit84.getTupleDecoder)([
+              (0, import_kit80.getTupleDecoder)([
                 getStakeOutputDecoder(),
-                (0, import_kit84.getArrayDecoder)((0, import_kit84.getU8Decoder)(), { size: 64 })
+                (0, import_kit80.getArrayDecoder)((0, import_kit80.getU8Decoder)(), { size: 64 })
               ])
             ]
           ])
         ],
-        ["Failure", (0, import_kit84.getUnitDecoder)()],
+        ["Failure", (0, import_kit80.getUnitDecoder)()],
         [
           "MarkerForIdlBuildDoNotUseThis",
-          (0, import_kit84.getStructDecoder)([
-            ["fields", (0, import_kit84.getTupleDecoder)([getStakeOutputDecoder()])]
+          (0, import_kit80.getStructDecoder)([
+            ["fields", (0, import_kit80.getTupleDecoder)([getStakeOutputDecoder()])]
           ])
         ]
       ])
@@ -6510,7 +6282,7 @@ function getStakeCallbackInstructionDataDecoder() {
   ]);
 }
 function getStakeCallbackInstructionDataCodec() {
-  return (0, import_kit84.combineCodec)(
+  return (0, import_kit80.combineCodec)(
     getStakeCallbackInstructionDataEncoder(),
     getStakeCallbackInstructionDataDecoder()
   );
@@ -6586,7 +6358,7 @@ function parseStakeCallbackInstruction(instruction) {
 }
 
 // src/generated/instructions/stakeCompDef.ts
-var import_kit85 = require("@solana/kit");
+var import_kit81 = require("@solana/kit");
 var STAKE_COMP_DEF_DISCRIMINATOR = new Uint8Array([
   156,
   5,
@@ -6598,23 +6370,23 @@ var STAKE_COMP_DEF_DISCRIMINATOR = new Uint8Array([
   130
 ]);
 function getStakeCompDefDiscriminatorBytes() {
-  return (0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
+  return (0, import_kit81.fixEncoderSize)((0, import_kit81.getBytesEncoder)(), 8).encode(
     STAKE_COMP_DEF_DISCRIMINATOR
   );
 }
 function getStakeCompDefInstructionDataEncoder() {
-  return (0, import_kit85.transformEncoder)(
-    (0, import_kit85.getStructEncoder)([["discriminator", (0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8)]]),
+  return (0, import_kit81.transformEncoder)(
+    (0, import_kit81.getStructEncoder)([["discriminator", (0, import_kit81.fixEncoderSize)((0, import_kit81.getBytesEncoder)(), 8)]]),
     (value) => ({ ...value, discriminator: STAKE_COMP_DEF_DISCRIMINATOR })
   );
 }
 function getStakeCompDefInstructionDataDecoder() {
-  return (0, import_kit85.getStructDecoder)([
-    ["discriminator", (0, import_kit85.fixDecoderSize)((0, import_kit85.getBytesDecoder)(), 8)]
+  return (0, import_kit81.getStructDecoder)([
+    ["discriminator", (0, import_kit81.fixDecoderSize)((0, import_kit81.getBytesDecoder)(), 8)]
   ]);
 }
 function getStakeCompDefInstructionDataCodec() {
-  return (0, import_kit85.combineCodec)(
+  return (0, import_kit81.combineCodec)(
     getStakeCompDefInstructionDataEncoder(),
     getStakeCompDefInstructionDataDecoder()
   );
@@ -6684,7 +6456,7 @@ function parseStakeCompDefInstruction(instruction) {
 }
 
 // src/generated/instructions/unstake.ts
-var import_kit86 = require("@solana/kit");
+var import_kit82 = require("@solana/kit");
 var UNSTAKE_DISCRIMINATOR = new Uint8Array([
   90,
   95,
@@ -6696,25 +6468,25 @@ var UNSTAKE_DISCRIMINATOR = new Uint8Array([
   225
 ]);
 function getUnstakeDiscriminatorBytes() {
-  return (0, import_kit86.fixEncoderSize)((0, import_kit86.getBytesEncoder)(), 8).encode(UNSTAKE_DISCRIMINATOR);
+  return (0, import_kit82.fixEncoderSize)((0, import_kit82.getBytesEncoder)(), 8).encode(UNSTAKE_DISCRIMINATOR);
 }
 function getUnstakeInstructionDataEncoder() {
-  return (0, import_kit86.transformEncoder)(
-    (0, import_kit86.getStructEncoder)([
-      ["discriminator", (0, import_kit86.fixEncoderSize)((0, import_kit86.getBytesEncoder)(), 8)],
-      ["stakeAccountId", (0, import_kit86.getU32Encoder)()]
+  return (0, import_kit82.transformEncoder)(
+    (0, import_kit82.getStructEncoder)([
+      ["discriminator", (0, import_kit82.fixEncoderSize)((0, import_kit82.getBytesEncoder)(), 8)],
+      ["stakeAccountId", (0, import_kit82.getU32Encoder)()]
     ]),
     (value) => ({ ...value, discriminator: UNSTAKE_DISCRIMINATOR })
   );
 }
 function getUnstakeInstructionDataDecoder() {
-  return (0, import_kit86.getStructDecoder)([
-    ["discriminator", (0, import_kit86.fixDecoderSize)((0, import_kit86.getBytesDecoder)(), 8)],
-    ["stakeAccountId", (0, import_kit86.getU32Decoder)()]
+  return (0, import_kit82.getStructDecoder)([
+    ["discriminator", (0, import_kit82.fixDecoderSize)((0, import_kit82.getBytesDecoder)(), 8)],
+    ["stakeAccountId", (0, import_kit82.getU32Decoder)()]
   ]);
 }
 function getUnstakeInstructionDataCodec() {
-  return (0, import_kit86.combineCodec)(
+  return (0, import_kit82.combineCodec)(
     getUnstakeInstructionDataEncoder(),
     getUnstakeInstructionDataDecoder()
   );
@@ -6738,10 +6510,10 @@ async function getUnstakeInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.stakeAccount.value) {
-    accounts.stakeAccount.value = await (0, import_kit86.getProgramDerivedAddress)({
+    accounts.stakeAccount.value = await (0, import_kit82.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        (0, import_kit86.getBytesEncoder)().encode(
+        (0, import_kit82.getBytesEncoder)().encode(
           new Uint8Array([
             115,
             116,
@@ -6758,19 +6530,19 @@ async function getUnstakeInstructionAsync(input, config) {
             116
           ])
         ),
-        (0, import_kit86.getAddressEncoder)().encode(expectAddress(accounts.owner.value)),
-        (0, import_kit86.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit86.getU32Encoder)().encode(expectSome(args.stakeAccountId))
+        (0, import_kit82.getAddressEncoder)().encode(expectAddress(accounts.owner.value)),
+        (0, import_kit82.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit82.getU32Encoder)().encode(expectSome(args.stakeAccountId))
       ]
     });
   }
   if (!accounts.marketTokenAta.value) {
-    accounts.marketTokenAta.value = await (0, import_kit86.getProgramDerivedAddress)({
+    accounts.marketTokenAta.value = await (0, import_kit82.getProgramDerivedAddress)({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        (0, import_kit86.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit86.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
-        (0, import_kit86.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
+        (0, import_kit82.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit82.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
+        (0, import_kit82.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -6864,7 +6636,7 @@ function parseUnstakeInstruction(instruction) {
 }
 
 // src/generated/instructions/updatePlatformConfig.ts
-var import_kit87 = require("@solana/kit");
+var import_kit83 = require("@solana/kit");
 var UPDATE_PLATFORM_CONFIG_DISCRIMINATOR = new Uint8Array([
   195,
   60,
@@ -6876,21 +6648,21 @@ var UPDATE_PLATFORM_CONFIG_DISCRIMINATOR = new Uint8Array([
   143
 ]);
 function getUpdatePlatformConfigDiscriminatorBytes() {
-  return (0, import_kit87.fixEncoderSize)((0, import_kit87.getBytesEncoder)(), 8).encode(
+  return (0, import_kit83.fixEncoderSize)((0, import_kit83.getBytesEncoder)(), 8).encode(
     UPDATE_PLATFORM_CONFIG_DISCRIMINATOR
   );
 }
 function getUpdatePlatformConfigInstructionDataEncoder() {
-  return (0, import_kit87.transformEncoder)(
-    (0, import_kit87.getStructEncoder)([
-      ["discriminator", (0, import_kit87.fixEncoderSize)((0, import_kit87.getBytesEncoder)(), 8)],
-      ["platformFeeBp", (0, import_kit87.getU16Encoder)()],
-      ["rewardPoolFeeBp", (0, import_kit87.getU16Encoder)()],
-      ["creatorFeeBp", (0, import_kit87.getU16Encoder)()],
-      ["minTimeToStakeSeconds", (0, import_kit87.getU64Encoder)()],
-      ["minRevealPeriodSeconds", (0, import_kit87.getU64Encoder)()],
-      ["maxRevealPeriodSeconds", (0, import_kit87.getU64Encoder)()],
-      ["marketResolutionDeadlineSeconds", (0, import_kit87.getU64Encoder)()]
+  return (0, import_kit83.transformEncoder)(
+    (0, import_kit83.getStructEncoder)([
+      ["discriminator", (0, import_kit83.fixEncoderSize)((0, import_kit83.getBytesEncoder)(), 8)],
+      ["platformFeeBp", (0, import_kit83.getU16Encoder)()],
+      ["rewardPoolFeeBp", (0, import_kit83.getU16Encoder)()],
+      ["creatorFeeBp", (0, import_kit83.getU16Encoder)()],
+      ["revealAuthority", (0, import_kit83.getAddressEncoder)()],
+      ["minTimeToStakeSeconds", (0, import_kit83.getU64Encoder)()],
+      ["revealPeriodSeconds", (0, import_kit83.getU64Encoder)()],
+      ["marketResolutionDeadlineSeconds", (0, import_kit83.getU64Encoder)()]
     ]),
     (value) => ({
       ...value,
@@ -6899,19 +6671,19 @@ function getUpdatePlatformConfigInstructionDataEncoder() {
   );
 }
 function getUpdatePlatformConfigInstructionDataDecoder() {
-  return (0, import_kit87.getStructDecoder)([
-    ["discriminator", (0, import_kit87.fixDecoderSize)((0, import_kit87.getBytesDecoder)(), 8)],
-    ["platformFeeBp", (0, import_kit87.getU16Decoder)()],
-    ["rewardPoolFeeBp", (0, import_kit87.getU16Decoder)()],
-    ["creatorFeeBp", (0, import_kit87.getU16Decoder)()],
-    ["minTimeToStakeSeconds", (0, import_kit87.getU64Decoder)()],
-    ["minRevealPeriodSeconds", (0, import_kit87.getU64Decoder)()],
-    ["maxRevealPeriodSeconds", (0, import_kit87.getU64Decoder)()],
-    ["marketResolutionDeadlineSeconds", (0, import_kit87.getU64Decoder)()]
+  return (0, import_kit83.getStructDecoder)([
+    ["discriminator", (0, import_kit83.fixDecoderSize)((0, import_kit83.getBytesDecoder)(), 8)],
+    ["platformFeeBp", (0, import_kit83.getU16Decoder)()],
+    ["rewardPoolFeeBp", (0, import_kit83.getU16Decoder)()],
+    ["creatorFeeBp", (0, import_kit83.getU16Decoder)()],
+    ["revealAuthority", (0, import_kit83.getAddressDecoder)()],
+    ["minTimeToStakeSeconds", (0, import_kit83.getU64Decoder)()],
+    ["revealPeriodSeconds", (0, import_kit83.getU64Decoder)()],
+    ["marketResolutionDeadlineSeconds", (0, import_kit83.getU64Decoder)()]
   ]);
 }
 function getUpdatePlatformConfigInstructionDataCodec() {
-  return (0, import_kit87.combineCodec)(
+  return (0, import_kit83.combineCodec)(
     getUpdatePlatformConfigInstructionDataEncoder(),
     getUpdatePlatformConfigInstructionDataDecoder()
   );
@@ -6962,7 +6734,7 @@ function parseUpdatePlatformConfigInstruction(instruction) {
 }
 
 // src/generated/instructions/withdrawReward.ts
-var import_kit88 = require("@solana/kit");
+var import_kit84 = require("@solana/kit");
 var WITHDRAW_REWARD_DISCRIMINATOR = new Uint8Array([
   191,
   187,
@@ -6974,23 +6746,23 @@ var WITHDRAW_REWARD_DISCRIMINATOR = new Uint8Array([
   244
 ]);
 function getWithdrawRewardDiscriminatorBytes() {
-  return (0, import_kit88.fixEncoderSize)((0, import_kit88.getBytesEncoder)(), 8).encode(
+  return (0, import_kit84.fixEncoderSize)((0, import_kit84.getBytesEncoder)(), 8).encode(
     WITHDRAW_REWARD_DISCRIMINATOR
   );
 }
 function getWithdrawRewardInstructionDataEncoder() {
-  return (0, import_kit88.transformEncoder)(
-    (0, import_kit88.getStructEncoder)([["discriminator", (0, import_kit88.fixEncoderSize)((0, import_kit88.getBytesEncoder)(), 8)]]),
+  return (0, import_kit84.transformEncoder)(
+    (0, import_kit84.getStructEncoder)([["discriminator", (0, import_kit84.fixEncoderSize)((0, import_kit84.getBytesEncoder)(), 8)]]),
     (value) => ({ ...value, discriminator: WITHDRAW_REWARD_DISCRIMINATOR })
   );
 }
 function getWithdrawRewardInstructionDataDecoder() {
-  return (0, import_kit88.getStructDecoder)([
-    ["discriminator", (0, import_kit88.fixDecoderSize)((0, import_kit88.getBytesDecoder)(), 8)]
+  return (0, import_kit84.getStructDecoder)([
+    ["discriminator", (0, import_kit84.fixDecoderSize)((0, import_kit84.getBytesDecoder)(), 8)]
   ]);
 }
 function getWithdrawRewardInstructionDataCodec() {
-  return (0, import_kit88.combineCodec)(
+  return (0, import_kit84.combineCodec)(
     getWithdrawRewardInstructionDataEncoder(),
     getWithdrawRewardInstructionDataDecoder()
   );
@@ -7011,24 +6783,24 @@ async function getWithdrawRewardInstructionAsync(input, config) {
   };
   const accounts = originalAccounts;
   if (!accounts.sponsorAccount.value) {
-    accounts.sponsorAccount.value = await (0, import_kit88.getProgramDerivedAddress)({
+    accounts.sponsorAccount.value = await (0, import_kit84.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        (0, import_kit88.getBytesEncoder)().encode(
+        (0, import_kit84.getBytesEncoder)().encode(
           new Uint8Array([115, 112, 111, 110, 115, 111, 114])
         ),
-        (0, import_kit88.getAddressEncoder)().encode(expectAddress(accounts.sponsor.value)),
-        (0, import_kit88.getAddressEncoder)().encode(expectAddress(accounts.market.value))
+        (0, import_kit84.getAddressEncoder)().encode(expectAddress(accounts.sponsor.value)),
+        (0, import_kit84.getAddressEncoder)().encode(expectAddress(accounts.market.value))
       ]
     });
   }
   if (!accounts.marketTokenAta.value) {
-    accounts.marketTokenAta.value = await (0, import_kit88.getProgramDerivedAddress)({
+    accounts.marketTokenAta.value = await (0, import_kit84.getProgramDerivedAddress)({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        (0, import_kit88.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
-        (0, import_kit88.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
-        (0, import_kit88.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
+        (0, import_kit84.getAddressEncoder)().encode(expectAddress(accounts.market.value)),
+        (0, import_kit84.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
+        (0, import_kit84.getAddressEncoder)().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -7134,7 +6906,7 @@ async function createMarket(input) {
 }
 
 // src/instructions/initCompDef.ts
-var import_kit89 = require("@solana/kit");
+var import_kit85 = require("@solana/kit");
 var import_client = require("@arcium-hq/client");
 var import_web3 = require("@solana/web3.js");
 var import_bn = require("bn.js");
@@ -7143,13 +6915,13 @@ var ALL_COMP_DEF_CIRCUITS = [
   "reveal_stake"
 ];
 function toAddress(pubkey) {
-  return (0, import_kit89.address)(pubkey.toBase58());
+  return (0, import_kit85.address)(pubkey.toBase58());
 }
 async function getMxeAccount(rpc, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
   const programIdLegacy = new import_web3.PublicKey(programId);
   const mxeAddress = toAddress((0, import_client.getMXEAccAddress)(programIdLegacy));
-  const encoded = await (0, import_kit89.fetchEncodedAccount)(rpc, mxeAddress);
-  (0, import_kit89.assertAccountExists)(encoded);
+  const encoded = await (0, import_kit85.fetchEncodedAccount)(rpc, mxeAddress);
+  (0, import_kit85.assertAccountExists)(encoded);
   const data = getMXEAccountDecoder().decode(encoded.data.slice(8));
   return { address: mxeAddress, data };
 }
@@ -7189,12 +6961,12 @@ async function getInitCompDefInstruction(rpc, payer, circuitName, config = {}) {
 }
 
 // src/arcium/computeAccounts.ts
-var import_kit90 = require("@solana/kit");
+var import_kit86 = require("@solana/kit");
 var import_client2 = require("@arcium-hq/client");
 var import_web32 = require("@solana/web3.js");
 var import_bn2 = __toESM(require("bn.js"), 1);
 function toAddress2(pubkey) {
-  return (0, import_kit90.address)(pubkey.toBase58());
+  return (0, import_kit86.address)(pubkey.toBase58());
 }
 function getComputeAccounts(ixName, config) {
   const programId = config.programId ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
@@ -7225,6 +6997,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 {
@@ -7265,6 +7075,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) {
@@ -7280,6 +7094,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) {
@@ -7299,24 +7117,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;
@@ -7417,15 +7217,15 @@ async function finalizeRevealStake(input) {
 }
 
 // src/accounts/platformConfig.ts
-var import_kit91 = require("@solana/kit");
+var import_kit87 = require("@solana/kit");
 var PLATFORM_CONFIG_SEED = "platform_config";
 async function getPlatformConfigAddress(authority, name, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
-  return (0, import_kit91.getProgramDerivedAddress)({
+  return (0, import_kit87.getProgramDerivedAddress)({
     programAddress: programId,
     seeds: [
       PLATFORM_CONFIG_SEED,
-      (0, import_kit91.getAddressEncoder)().encode(authority),
-      (0, import_kit91.getUtf8Encoder)().encode(name)
+      (0, import_kit87.getAddressEncoder)().encode(authority),
+      (0, import_kit87.getUtf8Encoder)().encode(name)
     ]
   });
 }
@@ -7440,9 +7240,9 @@ async function createPlatformConfig(rpc, params) {
     rewardPoolFeeBp,
     creatorFeeBp,
     feeClaimAuthority,
+    revealAuthority,
     minTimeToStakeSeconds,
-    minRevealPeriodSeconds,
-    maxRevealPeriodSeconds,
+    revealPeriodSeconds,
     marketResolutionDeadlineSeconds
   } = params;
   const [platformConfigAddress] = await getPlatformConfigAddress(
@@ -7464,9 +7264,9 @@ async function createPlatformConfig(rpc, params) {
       rewardPoolFeeBp,
       creatorFeeBp,
       feeClaimAuthority,
+      revealAuthority,
       minTimeToStakeSeconds,
-      minRevealPeriodSeconds,
-      maxRevealPeriodSeconds,
+      revealPeriodSeconds,
       marketResolutionDeadlineSeconds
     },
     programAddress ? { programAddress } : void 0
@@ -7482,9 +7282,9 @@ async function updatePlatformConfig(rpc, params) {
     platformFeeBp,
     rewardPoolFeeBp,
     creatorFeeBp,
+    revealAuthority,
     minTimeToStakeSeconds,
-    minRevealPeriodSeconds,
-    maxRevealPeriodSeconds,
+    revealPeriodSeconds,
     marketResolutionDeadlineSeconds
   } = params;
   const [platformConfigAddress] = await getPlatformConfigAddress(
@@ -7505,9 +7305,9 @@ async function updatePlatformConfig(rpc, params) {
       platformFeeBp,
       rewardPoolFeeBp,
       creatorFeeBp,
+      revealAuthority,
       minTimeToStakeSeconds,
-      minRevealPeriodSeconds,
-      maxRevealPeriodSeconds,
+      revealPeriodSeconds,
       marketResolutionDeadlineSeconds
     },
     programAddress ? { programAddress } : void 0
@@ -7560,51 +7360,51 @@ function setFeeClaimAuthority(input) {
 }
 
 // src/accounts/allowedMint.ts
-var import_kit92 = require("@solana/kit");
+var import_kit88 = require("@solana/kit");
 var ALLOWED_MINT_SEED = "allowed_mint";
 async function getAllowedMintAddress(platformConfig, mint, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
-  const enc = (0, import_kit92.getAddressEncoder)();
-  return (0, import_kit92.getProgramDerivedAddress)({
+  const enc = (0, import_kit88.getAddressEncoder)();
+  return (0, import_kit88.getProgramDerivedAddress)({
     programAddress: programId,
     seeds: [ALLOWED_MINT_SEED, enc.encode(platformConfig), enc.encode(mint)]
   });
 }
 
 // src/accounts/opportunityMarket.ts
-var import_kit93 = require("@solana/kit");
+var import_kit89 = require("@solana/kit");
 var OPPORTUNITY_MARKET_SEED = "opportunity_market";
 async function getOpportunityMarketAddress(platformConfig, creator, marketIndex, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
-  return (0, import_kit93.getProgramDerivedAddress)({
+  return (0, import_kit89.getProgramDerivedAddress)({
     programAddress: programId,
     seeds: [
       OPPORTUNITY_MARKET_SEED,
-      (0, import_kit93.getAddressEncoder)().encode(platformConfig),
-      (0, import_kit93.getAddressEncoder)().encode(creator),
-      (0, import_kit93.getU64Encoder)().encode(BigInt(marketIndex))
+      (0, import_kit89.getAddressEncoder)().encode(platformConfig),
+      (0, import_kit89.getAddressEncoder)().encode(creator),
+      (0, import_kit89.getU64Encoder)().encode(BigInt(marketIndex))
     ]
   });
 }
 
 // src/accounts/opportunityMarketOption.ts
-var import_kit94 = require("@solana/kit");
+var import_kit90 = require("@solana/kit");
 var OPPORTUNITY_MARKET_OPTION_SEED = "option";
 async function getOpportunityMarketOptionAddress(market, optionId, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
-  return (0, import_kit94.getProgramDerivedAddress)({
+  return (0, import_kit90.getProgramDerivedAddress)({
     programAddress: programId,
     seeds: [
       OPPORTUNITY_MARKET_OPTION_SEED,
-      (0, import_kit94.getAddressEncoder)().encode(market),
-      (0, import_kit94.getU64Encoder)().encode(optionId)
+      (0, import_kit90.getAddressEncoder)().encode(market),
+      (0, import_kit90.getU64Encoder)().encode(optionId)
     ]
   });
 }
 
 // src/accounts/opportunityMarketSponsor.ts
-var import_kit95 = require("@solana/kit");
+var import_kit91 = require("@solana/kit");
 var SPONSOR_SEED = "sponsor";
 async function getOpportunityMarketSponsorAddress(sponsor, market, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
-  const addressEncoder = (0, import_kit95.getAddressEncoder)();
-  return (0, import_kit95.getProgramDerivedAddress)({
+  const addressEncoder = (0, import_kit91.getAddressEncoder)();
+  return (0, import_kit91.getProgramDerivedAddress)({
     programAddress: programId,
     seeds: [
       SPONSOR_SEED,
@@ -7615,13 +7415,13 @@ async function getOpportunityMarketSponsorAddress(sponsor, market, programId = O
 }
 
 // src/accounts/stakeAccount.ts
-var import_kit96 = require("@solana/kit");
+var import_kit92 = require("@solana/kit");
 var STAKE_ACCOUNT_SEED = "stake_account";
 async function getStakeAccountAddress(owner, market, stakeAccountId, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
-  const addressEncoder = (0, import_kit96.getAddressEncoder)();
+  const addressEncoder = (0, import_kit92.getAddressEncoder)();
   const idBytes = new Uint8Array(4);
   new DataView(idBytes.buffer).setUint32(0, stakeAccountId, true);
-  return (0, import_kit96.getProgramDerivedAddress)({
+  return (0, import_kit92.getProgramDerivedAddress)({
     programAddress: programId,
     seeds: [
       STAKE_ACCOUNT_SEED,
@@ -7632,115 +7432,6 @@ async function getStakeAccountAddress(owner, market, stakeAccountId, programId =
   });
 }
 
-// src/arcium/awaitFinalizeComputation.ts
-var import_kit97 = require("@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 = (0, import_kit97.getAddressEncoder)().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
 var import_client3 = require("@arcium-hq/client");
 var import_bn3 = require("bn.js");
@@ -7805,11 +7496,10 @@ function nonceToBytes(nonce) {
   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,
@@ -7832,12 +7522,10 @@ function nonceToBytes(nonce) {
   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,
@@ -7855,8 +7543,9 @@ function nonceToBytes(nonce) {
   WITHDRAW_REWARD_DISCRIMINATOR,
   addMarketOption,
   addReward,
-  awaitBatchComputationFinalization,
   awaitComputationFinalization,
+  awaitRevealStakeFinalization,
+  awaitStakeFinalization,
   circuitSource,
   claimCreatorFees,
   claimFees,
@@ -8107,11 +7796,6 @@ function nonceToBytes(nonce) {
   getParameterCodec,
   getParameterDecoder,
   getParameterEncoder,
-  getPauseStakingDiscriminatorBytes,
-  getPauseStakingInstruction,
-  getPauseStakingInstructionDataCodec,
-  getPauseStakingInstructionDataDecoder,
-  getPauseStakingInstructionDataEncoder,
   getPlatformConfigAddress,
   getPlatformConfigCodec,
   getPlatformConfigDecoder,
@@ -8122,11 +7806,6 @@ function nonceToBytes(nonce) {
   getResolveMarketInstructionDataCodec,
   getResolveMarketInstructionDataDecoder,
   getResolveMarketInstructionDataEncoder,
-  getResumeStakingDiscriminatorBytes,
-  getResumeStakingInstruction,
-  getResumeStakingInstructionDataCodec,
-  getResumeStakingInstructionDataDecoder,
-  getResumeStakingInstructionDataEncoder,
   getRevealPeriodEndedEventCodec,
   getRevealPeriodEndedEventDecoder,
   getRevealPeriodEndedEventEncoder,
@@ -8213,12 +7892,6 @@ function nonceToBytes(nonce) {
   getStakedEventCodec,
   getStakedEventDecoder,
   getStakedEventEncoder,
-  getStakingPausedEventCodec,
-  getStakingPausedEventDecoder,
-  getStakingPausedEventEncoder,
-  getStakingResumedEventCodec,
-  getStakingResumedEventDecoder,
-  getStakingResumedEventEncoder,
   getStuckStakeClosedEventCodec,
   getStuckStakeClosedEventDecoder,
   getStuckStakeClosedEventEncoder,
@@ -8276,9 +7949,7 @@ function nonceToBytes(nonce) {
   parseInitPlatformConfigInstruction,
   parseInitStakeAccountInstruction,
   parseOpenMarketInstruction,
-  parsePauseStakingInstruction,
   parseResolveMarketInstruction,
-  parseResumeStakingInstruction,
   parseRevealStakeCallbackInstruction,
   parseRevealStakeCompDefInstruction,
   parseRevealStakeInstruction,
@@ -8291,11 +7962,9 @@ function nonceToBytes(nonce) {
   parseUnstakeInstruction,
   parseUpdatePlatformConfigInstruction,
   parseWithdrawRewardInstruction,
-  pauseStaking,
   randomComputationOffset,
   randomStateNonce,
   resolveMarket,
-  resumeStaking,
   revealStake,
   setFeeClaimAuthority,
   setUpdateAuthority,