@bench.games/opportunity-markets 0.3.5 → 0.4.4

package/dist/index.js

@@ -623,7 +623,7 @@ function getCreateMarketParametersEncoder() {
     ["authorizedReaderPubkey", getArrayEncoder5(getU8Encoder7(), { size: 32 })],
     ["earlinessCutoffSeconds", getU64Encoder4()],
     ["earlinessMultiplier", getU16Encoder2()],
-    ["minStakeAmount", getU64Encoder4()],
+    ["minVouchAmount", getU64Encoder4()],
     ["creatorFeeClaimer", getAddressEncoder4()]
   ]);
 }
@@ -634,7 +634,7 @@ function getCreateMarketParametersDecoder() {
     ["authorizedReaderPubkey", getArrayDecoder5(getU8Decoder7(), { size: 32 })],
     ["earlinessCutoffSeconds", getU64Decoder4()],
     ["earlinessMultiplier", getU16Decoder2()],
-    ["minStakeAmount", getU64Decoder4()],
+    ["minVouchAmount", getU64Decoder4()],
     ["creatorFeeClaimer", getAddressDecoder4()]
   ]);
 }
@@ -844,7 +844,7 @@ function getInitPlatformParametersEncoder() {
     ["creatorFeeBp", getU16Encoder4()],
     ["feeClaimAuthority", getAddressEncoder8()],
     ["revealAuthority", getAddressEncoder8()],
-    ["minTimeToStakeSeconds", getU64Encoder8()],
+    ["minTimeToVouchSeconds", getU64Encoder8()],
     ["revealPeriodSeconds", getU64Encoder8()],
     ["marketResolutionDeadlineSeconds", getU64Encoder8()]
   ]);
@@ -857,7 +857,7 @@ function getInitPlatformParametersDecoder() {
     ["creatorFeeBp", getU16Decoder4()],
     ["feeClaimAuthority", getAddressDecoder8()],
     ["revealAuthority", getAddressDecoder8()],
-    ["minTimeToStakeSeconds", getU64Decoder8()],
+    ["minTimeToVouchSeconds", getU64Decoder8()],
     ["revealPeriodSeconds", getU64Decoder8()],
     ["marketResolutionDeadlineSeconds", getU64Decoder8()]
   ]);
@@ -923,7 +923,7 @@ function getMarketCreatedEventEncoder() {
     ["earlinessMultiplier", getU16Encoder5()],
     ["marketAuthority", getAddressEncoder9()],
     ["authorizedReaderPubkey", getArrayEncoder6(getU8Encoder9(), { size: 32 })],
-    ["minStakeAmount", getU64Encoder9()],
+    ["minVouchAmount", getU64Encoder9()],
     ["feeRates", getFeeRatesEncoder()],
     ["creatorFeeClaimer", getAddressEncoder9()],
     ["marketResolutionDeadlineSeconds", getU64Encoder9()],
@@ -942,7 +942,7 @@ function getMarketCreatedEventDecoder() {
     ["earlinessMultiplier", getU16Decoder5()],
     ["marketAuthority", getAddressDecoder9()],
     ["authorizedReaderPubkey", getArrayDecoder6(getU8Decoder9(), { size: 32 })],
-    ["minStakeAmount", getU64Decoder9()],
+    ["minVouchAmount", getU64Decoder9()],
     ["feeRates", getFeeRatesDecoder()],
     ["creatorFeeClaimer", getAddressDecoder9()],
     ["marketResolutionDeadlineSeconds", getU64Decoder9()],
@@ -973,7 +973,7 @@ function getMarketOpenedEventEncoder() {
   return getStructEncoder20([
     ["market", getAddressEncoder10()],
     ["creator", getAddressEncoder10()],
-    ["stakingWindowEnd", getU64Encoder10()],
+    ["vouchingWindowEnd", getU64Encoder10()],
     ["timestamp", getI64Encoder6()]
   ]);
 }
@@ -981,7 +981,7 @@ function getMarketOpenedEventDecoder() {
   return getStructDecoder20([
     ["market", getAddressDecoder10()],
     ["creator", getAddressDecoder10()],
-    ["stakingWindowEnd", getU64Decoder10()],
+    ["vouchingWindowEnd", getU64Decoder10()],
     ["timestamp", getI64Decoder6()]
   ]);
 }
@@ -1444,7 +1444,7 @@ function getRevealPeriodEndedEventCodec() {
   );
 }
 
-// src/generated/types/revealStakeFinalizedEvent.ts
+// src/generated/types/revealVouchFinalizedEvent.ts
 import {
   combineCodec as combineCodec36,
   getAddressDecoder as getAddressDecoder17,
@@ -1460,42 +1460,42 @@ import {
   getU64Decoder as getU64Decoder15,
   getU64Encoder as getU64Encoder15
 } from "@solana/kit";
-function getRevealStakeFinalizedEventEncoder() {
+function getRevealVouchFinalizedEventEncoder() {
   return getStructEncoder30([
     ["owner", getAddressEncoder17()],
     ["market", getAddressEncoder17()],
-    ["stakeAccount", getAddressEncoder17()],
-    ["stakeAccountId", getU32Encoder7()],
+    ["vouchAccount", getAddressEncoder17()],
+    ["vouchAccountId", getU32Encoder7()],
     ["optionId", getU64Encoder15()],
-    ["userStake", getU64Encoder15()],
+    ["userVouch", getU64Encoder15()],
     ["userScore", getU64Encoder15()],
     ["totalScore", getU128Encoder()],
-    ["totalStake", getU64Encoder15()],
+    ["totalVouch", getU64Encoder15()],
     ["timestamp", getI64Encoder11()]
   ]);
 }
-function getRevealStakeFinalizedEventDecoder() {
+function getRevealVouchFinalizedEventDecoder() {
   return getStructDecoder30([
     ["owner", getAddressDecoder17()],
     ["market", getAddressDecoder17()],
-    ["stakeAccount", getAddressDecoder17()],
-    ["stakeAccountId", getU32Decoder7()],
+    ["vouchAccount", getAddressDecoder17()],
+    ["vouchAccountId", getU32Decoder7()],
     ["optionId", getU64Decoder15()],
-    ["userStake", getU64Decoder15()],
+    ["userVouch", getU64Decoder15()],
     ["userScore", getU64Decoder15()],
     ["totalScore", getU128Decoder()],
-    ["totalStake", getU64Decoder15()],
+    ["totalVouch", getU64Decoder15()],
     ["timestamp", getI64Decoder11()]
   ]);
 }
-function getRevealStakeFinalizedEventCodec() {
+function getRevealVouchFinalizedEventCodec() {
   return combineCodec36(
-    getRevealStakeFinalizedEventEncoder(),
-    getRevealStakeFinalizedEventDecoder()
+    getRevealVouchFinalizedEventEncoder(),
+    getRevealVouchFinalizedEventDecoder()
   );
 }
 
-// src/generated/types/revealStakeOutput.ts
+// src/generated/types/revealVouchOutput.ts
 import {
   combineCodec as combineCodec37,
   getStructDecoder as getStructDecoder31,
@@ -1503,16 +1503,16 @@ import {
   getU64Decoder as getU64Decoder16,
   getU64Encoder as getU64Encoder16
 } from "@solana/kit";
-function getRevealStakeOutputEncoder() {
+function getRevealVouchOutputEncoder() {
   return getStructEncoder31([["field0", getU64Encoder16()]]);
 }
-function getRevealStakeOutputDecoder() {
+function getRevealVouchOutputDecoder() {
   return getStructDecoder31([["field0", getU64Decoder16()]]);
 }
-function getRevealStakeOutputCodec() {
+function getRevealVouchOutputCodec() {
   return combineCodec37(
-    getRevealStakeOutputEncoder(),
-    getRevealStakeOutputDecoder()
+    getRevealVouchOutputEncoder(),
+    getRevealVouchOutputDecoder()
   );
 }
 
@@ -1571,8 +1571,8 @@ function getRewardsClaimedEventEncoder() {
   return getStructEncoder33([
     ["owner", getAddressEncoder19()],
     ["market", getAddressEncoder19()],
-    ["stakeAccount", getAddressEncoder19()],
-    ["stakeAccountId", getU32Encoder8()],
+    ["vouchAccount", getAddressEncoder19()],
+    ["vouchAccountId", getU32Encoder8()],
     ["optionId", getU64Encoder18()],
     ["rewardAmount", getU64Encoder18()],
     ["score", getU64Encoder18()],
@@ -1583,8 +1583,8 @@ function getRewardsClaimedEventDecoder() {
   return getStructDecoder33([
     ["owner", getAddressDecoder19()],
     ["market", getAddressDecoder19()],
-    ["stakeAccount", getAddressDecoder19()],
-    ["stakeAccountId", getU32Decoder8()],
+    ["vouchAccount", getAddressDecoder19()],
+    ["vouchAccountId", getU32Decoder8()],
     ["optionId", getU64Decoder18()],
     ["rewardAmount", getU64Decoder18()],
     ["score", getU64Decoder18()],
@@ -1635,15 +1635,13 @@ function getRewardWithdrawnEventCodec() {
   );
 }
 
-// src/generated/types/stakeAccountClosedEvent.ts
+// src/generated/types/stuckVouchClosedEvent.ts
 import {
   combineCodec as combineCodec41,
   getAddressDecoder as getAddressDecoder21,
   getAddressEncoder as getAddressEncoder21,
   getI64Decoder as getI64Decoder15,
   getI64Encoder as getI64Encoder15,
-  getOptionDecoder as getOptionDecoder4,
-  getOptionEncoder as getOptionEncoder4,
   getStructDecoder as getStructDecoder35,
   getStructEncoder as getStructEncoder35,
   getU32Decoder as getU32Decoder9,
@@ -1651,176 +1649,349 @@ import {
   getU64Decoder as getU64Decoder20,
   getU64Encoder as getU64Encoder20
 } from "@solana/kit";
-function getStakeAccountClosedEventEncoder() {
+function getStuckVouchClosedEventEncoder() {
   return getStructEncoder35([
     ["owner", getAddressEncoder21()],
     ["market", getAddressEncoder21()],
-    ["stakeAccount", getAddressEncoder21()],
-    ["stakeAccountId", getU32Encoder9()],
-    ["optionId", getOptionEncoder4(getU64Encoder20())],
-    ["stakeAmount", getU64Encoder20()],
-    ["feeRefund", getU64Encoder20()],
-    ["stakedAtTimestamp", getU64Encoder20()],
-    ["stakingWindowEnd", getU64Encoder20()],
-    ["score", getU64Encoder20()],
+    ["vouchAccount", getAddressEncoder21()],
+    ["vouchAccountId", getU32Encoder9()],
+    ["refundedAmount", getU64Encoder20()],
+    ["refundedPlatformFee", getU64Encoder20()],
+    ["refundedRewardPoolFee", getU64Encoder20()],
+    ["refundedCreatorFee", getU64Encoder20()],
     ["timestamp", getI64Encoder15()]
   ]);
 }
-function getStakeAccountClosedEventDecoder() {
+function getStuckVouchClosedEventDecoder() {
   return getStructDecoder35([
     ["owner", getAddressDecoder21()],
     ["market", getAddressDecoder21()],
-    ["stakeAccount", getAddressDecoder21()],
-    ["stakeAccountId", getU32Decoder9()],
-    ["optionId", getOptionDecoder4(getU64Decoder20())],
-    ["stakeAmount", getU64Decoder20()],
-    ["feeRefund", getU64Decoder20()],
-    ["stakedAtTimestamp", getU64Decoder20()],
-    ["stakingWindowEnd", getU64Decoder20()],
-    ["score", getU64Decoder20()],
+    ["vouchAccount", getAddressDecoder21()],
+    ["vouchAccountId", getU32Decoder9()],
+    ["refundedAmount", getU64Decoder20()],
+    ["refundedPlatformFee", getU64Decoder20()],
+    ["refundedRewardPoolFee", getU64Decoder20()],
+    ["refundedCreatorFee", getU64Decoder20()],
     ["timestamp", getI64Decoder15()]
   ]);
 }
-function getStakeAccountClosedEventCodec() {
+function getStuckVouchClosedEventCodec() {
   return combineCodec41(
-    getStakeAccountClosedEventEncoder(),
-    getStakeAccountClosedEventDecoder()
+    getStuckVouchClosedEventEncoder(),
+    getStuckVouchClosedEventDecoder()
   );
 }
 
-// src/generated/types/stakeAccountInitializedEvent.ts
+// src/generated/types/timestamp.ts
 import {
   combineCodec as combineCodec42,
+  getStructDecoder as getStructDecoder36,
+  getStructEncoder as getStructEncoder36,
+  getU64Decoder as getU64Decoder21,
+  getU64Encoder as getU64Encoder21
+} from "@solana/kit";
+function getTimestampEncoder() {
+  return getStructEncoder36([["timestamp", getU64Encoder21()]]);
+}
+function getTimestampDecoder() {
+  return getStructDecoder36([["timestamp", getU64Decoder21()]]);
+}
+function getTimestampCodec() {
+  return combineCodec42(getTimestampEncoder(), getTimestampDecoder());
+}
+
+// src/generated/types/updateAuthorityChangedEvent.ts
+import {
+  combineCodec as combineCodec43,
   getAddressDecoder as getAddressDecoder22,
   getAddressEncoder as getAddressEncoder22,
   getI64Decoder as getI64Decoder16,
   getI64Encoder as getI64Encoder16,
-  getStructDecoder as getStructDecoder36,
-  getStructEncoder as getStructEncoder36,
-  getU32Decoder as getU32Decoder10,
-  getU32Encoder as getU32Encoder10
+  getStructDecoder as getStructDecoder37,
+  getStructEncoder as getStructEncoder37
 } from "@solana/kit";
-function getStakeAccountInitializedEventEncoder() {
-  return getStructEncoder36([
-    ["stakeAccount", getAddressEncoder22()],
-    ["owner", getAddressEncoder22()],
-    ["market", getAddressEncoder22()],
-    ["accountId", getU32Encoder10()],
+function getUpdateAuthorityChangedEventEncoder() {
+  return getStructEncoder37([
+    ["platformConfig", getAddressEncoder22()],
+    ["oldValue", getAddressEncoder22()],
+    ["newValue", getAddressEncoder22()],
     ["timestamp", getI64Encoder16()]
   ]);
 }
-function getStakeAccountInitializedEventDecoder() {
-  return getStructDecoder36([
-    ["stakeAccount", getAddressDecoder22()],
-    ["owner", getAddressDecoder22()],
-    ["market", getAddressDecoder22()],
-    ["accountId", getU32Decoder10()],
+function getUpdateAuthorityChangedEventDecoder() {
+  return getStructDecoder37([
+    ["platformConfig", getAddressDecoder22()],
+    ["oldValue", getAddressDecoder22()],
+    ["newValue", getAddressDecoder22()],
     ["timestamp", getI64Decoder16()]
   ]);
 }
-function getStakeAccountInitializedEventCodec() {
-  return combineCodec42(
-    getStakeAccountInitializedEventEncoder(),
-    getStakeAccountInitializedEventDecoder()
+function getUpdateAuthorityChangedEventCodec() {
+  return combineCodec43(
+    getUpdateAuthorityChangedEventEncoder(),
+    getUpdateAuthorityChangedEventDecoder()
   );
 }
 
-// src/generated/types/stakedEvent.ts
+// src/generated/types/updatePlatformParameters.ts
 import {
-  combineCodec as combineCodec43,
+  combineCodec as combineCodec44,
   getAddressDecoder as getAddressDecoder23,
   getAddressEncoder as getAddressEncoder23,
+  getOptionDecoder as getOptionDecoder4,
+  getOptionEncoder as getOptionEncoder4,
+  getStructDecoder as getStructDecoder38,
+  getStructEncoder as getStructEncoder38,
+  getU16Decoder as getU16Decoder6,
+  getU16Encoder as getU16Encoder6,
+  getU64Decoder as getU64Decoder22,
+  getU64Encoder as getU64Encoder22
+} from "@solana/kit";
+function getUpdatePlatformParametersEncoder() {
+  return getStructEncoder38([
+    ["platformFeeBp", getOptionEncoder4(getU16Encoder6())],
+    ["rewardPoolFeeBp", getOptionEncoder4(getU16Encoder6())],
+    ["creatorFeeBp", getOptionEncoder4(getU16Encoder6())],
+    ["revealAuthority", getOptionEncoder4(getAddressEncoder23())],
+    ["minTimeToVouchSeconds", getOptionEncoder4(getU64Encoder22())],
+    ["revealPeriodSeconds", getOptionEncoder4(getU64Encoder22())],
+    ["marketResolutionDeadlineSeconds", getOptionEncoder4(getU64Encoder22())]
+  ]);
+}
+function getUpdatePlatformParametersDecoder() {
+  return getStructDecoder38([
+    ["platformFeeBp", getOptionDecoder4(getU16Decoder6())],
+    ["rewardPoolFeeBp", getOptionDecoder4(getU16Decoder6())],
+    ["creatorFeeBp", getOptionDecoder4(getU16Decoder6())],
+    ["revealAuthority", getOptionDecoder4(getAddressDecoder23())],
+    ["minTimeToVouchSeconds", getOptionDecoder4(getU64Decoder22())],
+    ["revealPeriodSeconds", getOptionDecoder4(getU64Decoder22())],
+    ["marketResolutionDeadlineSeconds", getOptionDecoder4(getU64Decoder22())]
+  ]);
+}
+function getUpdatePlatformParametersCodec() {
+  return combineCodec44(
+    getUpdatePlatformParametersEncoder(),
+    getUpdatePlatformParametersDecoder()
+  );
+}
+
+// src/generated/types/utilityPubkeys.ts
+import {
+  combineCodec as combineCodec45,
   getArrayDecoder as getArrayDecoder10,
   getArrayEncoder as getArrayEncoder10,
+  getStructDecoder as getStructDecoder39,
+  getStructEncoder as getStructEncoder39,
+  getU8Decoder as getU8Decoder14,
+  getU8Encoder as getU8Encoder14
+} from "@solana/kit";
+function getUtilityPubkeysEncoder() {
+  return getStructEncoder39([
+    ["x25519Pubkey", getArrayEncoder10(getU8Encoder14(), { size: 32 })],
+    ["ed25519VerifyingKey", getArrayEncoder10(getU8Encoder14(), { size: 32 })],
+    ["elgamalPubkey", getArrayEncoder10(getU8Encoder14(), { size: 32 })],
+    ["pubkeyValidityProof", getArrayEncoder10(getU8Encoder14(), { size: 64 })]
+  ]);
+}
+function getUtilityPubkeysDecoder() {
+  return getStructDecoder39([
+    ["x25519Pubkey", getArrayDecoder10(getU8Decoder14(), { size: 32 })],
+    ["ed25519VerifyingKey", getArrayDecoder10(getU8Decoder14(), { size: 32 })],
+    ["elgamalPubkey", getArrayDecoder10(getU8Decoder14(), { size: 32 })],
+    ["pubkeyValidityProof", getArrayDecoder10(getU8Decoder14(), { size: 64 })]
+  ]);
+}
+function getUtilityPubkeysCodec() {
+  return combineCodec45(getUtilityPubkeysEncoder(), getUtilityPubkeysDecoder());
+}
+
+// src/generated/types/vouchAccountClosedEvent.ts
+import {
+  combineCodec as combineCodec46,
+  getAddressDecoder as getAddressDecoder24,
+  getAddressEncoder as getAddressEncoder24,
   getI64Decoder as getI64Decoder17,
   getI64Encoder as getI64Encoder17,
-  getStructDecoder as getStructDecoder37,
-  getStructEncoder as getStructEncoder37,
+  getOptionDecoder as getOptionDecoder5,
+  getOptionEncoder as getOptionEncoder5,
+  getStructDecoder as getStructDecoder40,
+  getStructEncoder as getStructEncoder40,
+  getU32Decoder as getU32Decoder10,
+  getU32Encoder as getU32Encoder10,
+  getU64Decoder as getU64Decoder23,
+  getU64Encoder as getU64Encoder23
+} from "@solana/kit";
+function getVouchAccountClosedEventEncoder() {
+  return getStructEncoder40([
+    ["owner", getAddressEncoder24()],
+    ["market", getAddressEncoder24()],
+    ["vouchAccount", getAddressEncoder24()],
+    ["vouchAccountId", getU32Encoder10()],
+    ["optionId", getOptionEncoder5(getU64Encoder23())],
+    ["vouchAmount", getU64Encoder23()],
+    ["feeRefund", getU64Encoder23()],
+    ["vouchedAtTimestamp", getU64Encoder23()],
+    ["vouchingWindowEnd", getU64Encoder23()],
+    ["score", getU64Encoder23()],
+    ["timestamp", getI64Encoder17()]
+  ]);
+}
+function getVouchAccountClosedEventDecoder() {
+  return getStructDecoder40([
+    ["owner", getAddressDecoder24()],
+    ["market", getAddressDecoder24()],
+    ["vouchAccount", getAddressDecoder24()],
+    ["vouchAccountId", getU32Decoder10()],
+    ["optionId", getOptionDecoder5(getU64Decoder23())],
+    ["vouchAmount", getU64Decoder23()],
+    ["feeRefund", getU64Decoder23()],
+    ["vouchedAtTimestamp", getU64Decoder23()],
+    ["vouchingWindowEnd", getU64Decoder23()],
+    ["score", getU64Decoder23()],
+    ["timestamp", getI64Decoder17()]
+  ]);
+}
+function getVouchAccountClosedEventCodec() {
+  return combineCodec46(
+    getVouchAccountClosedEventEncoder(),
+    getVouchAccountClosedEventDecoder()
+  );
+}
+
+// src/generated/types/vouchAccountInitializedEvent.ts
+import {
+  combineCodec as combineCodec47,
+  getAddressDecoder as getAddressDecoder25,
+  getAddressEncoder as getAddressEncoder25,
+  getI64Decoder as getI64Decoder18,
+  getI64Encoder as getI64Encoder18,
+  getStructDecoder as getStructDecoder41,
+  getStructEncoder as getStructEncoder41,
+  getU32Decoder as getU32Decoder11,
+  getU32Encoder as getU32Encoder11
+} from "@solana/kit";
+function getVouchAccountInitializedEventEncoder() {
+  return getStructEncoder41([
+    ["vouchAccount", getAddressEncoder25()],
+    ["owner", getAddressEncoder25()],
+    ["market", getAddressEncoder25()],
+    ["accountId", getU32Encoder11()],
+    ["timestamp", getI64Encoder18()]
+  ]);
+}
+function getVouchAccountInitializedEventDecoder() {
+  return getStructDecoder41([
+    ["vouchAccount", getAddressDecoder25()],
+    ["owner", getAddressDecoder25()],
+    ["market", getAddressDecoder25()],
+    ["accountId", getU32Decoder11()],
+    ["timestamp", getI64Decoder18()]
+  ]);
+}
+function getVouchAccountInitializedEventCodec() {
+  return combineCodec47(
+    getVouchAccountInitializedEventEncoder(),
+    getVouchAccountInitializedEventDecoder()
+  );
+}
+
+// src/generated/types/vouchedEvent.ts
+import {
+  combineCodec as combineCodec48,
+  getAddressDecoder as getAddressDecoder26,
+  getAddressEncoder as getAddressEncoder26,
+  getArrayDecoder as getArrayDecoder11,
+  getArrayEncoder as getArrayEncoder11,
+  getI64Decoder as getI64Decoder19,
+  getI64Encoder as getI64Encoder19,
+  getStructDecoder as getStructDecoder42,
+  getStructEncoder as getStructEncoder42,
   getU128Decoder as getU128Decoder2,
   getU128Encoder as getU128Encoder2,
-  getU32Decoder as getU32Decoder11,
-  getU32Encoder as getU32Encoder11,
-  getU64Decoder as getU64Decoder21,
-  getU64Encoder as getU64Encoder21,
-  getU8Decoder as getU8Decoder14,
-  getU8Encoder as getU8Encoder14
+  getU32Decoder as getU32Decoder12,
+  getU32Encoder as getU32Encoder12,
+  getU64Decoder as getU64Decoder24,
+  getU64Encoder as getU64Encoder24,
+  getU8Decoder as getU8Decoder15,
+  getU8Encoder as getU8Encoder15
 } from "@solana/kit";
-function getStakedEventEncoder() {
-  return getStructEncoder37([
-    ["user", getAddressEncoder23()],
-    ["market", getAddressEncoder23()],
-    ["stakeAccount", getAddressEncoder23()],
-    ["stakeAccountId", getU32Encoder11()],
-    ["stakeEncryptedOption", getArrayEncoder10(getU8Encoder14(), { size: 32 })],
-    ["stakeStateNonce", getU128Encoder2()],
+function getVouchedEventEncoder() {
+  return getStructEncoder42([
+    ["user", getAddressEncoder26()],
+    ["market", getAddressEncoder26()],
+    ["vouchAccount", getAddressEncoder26()],
+    ["vouchAccountId", getU32Encoder12()],
+    ["vouchEncryptedOption", getArrayEncoder11(getU8Encoder15(), { size: 32 })],
+    ["vouchStateNonce", getU128Encoder2()],
     [
-      "stakeEncryptedOptionDisclosure",
-      getArrayEncoder10(getU8Encoder14(), { size: 32 })
+      "vouchEncryptedOptionDisclosure",
+      getArrayEncoder11(getU8Encoder15(), { size: 32 })
     ],
-    ["stakeStateDisclosureNonce", getU128Encoder2()],
-    ["amount", getU64Encoder21()],
-    ["timestamp", getI64Encoder17()]
+    ["vouchStateDisclosureNonce", getU128Encoder2()],
+    ["amount", getU64Encoder24()],
+    ["timestamp", getI64Encoder19()]
   ]);
 }
-function getStakedEventDecoder() {
-  return getStructDecoder37([
-    ["user", getAddressDecoder23()],
-    ["market", getAddressDecoder23()],
-    ["stakeAccount", getAddressDecoder23()],
-    ["stakeAccountId", getU32Decoder11()],
-    ["stakeEncryptedOption", getArrayDecoder10(getU8Decoder14(), { size: 32 })],
-    ["stakeStateNonce", getU128Decoder2()],
+function getVouchedEventDecoder() {
+  return getStructDecoder42([
+    ["user", getAddressDecoder26()],
+    ["market", getAddressDecoder26()],
+    ["vouchAccount", getAddressDecoder26()],
+    ["vouchAccountId", getU32Decoder12()],
+    ["vouchEncryptedOption", getArrayDecoder11(getU8Decoder15(), { size: 32 })],
+    ["vouchStateNonce", getU128Decoder2()],
     [
-      "stakeEncryptedOptionDisclosure",
-      getArrayDecoder10(getU8Decoder14(), { size: 32 })
+      "vouchEncryptedOptionDisclosure",
+      getArrayDecoder11(getU8Decoder15(), { size: 32 })
     ],
-    ["stakeStateDisclosureNonce", getU128Decoder2()],
-    ["amount", getU64Decoder21()],
-    ["timestamp", getI64Decoder17()]
+    ["vouchStateDisclosureNonce", getU128Decoder2()],
+    ["amount", getU64Decoder24()],
+    ["timestamp", getI64Decoder19()]
   ]);
 }
-function getStakedEventCodec() {
-  return combineCodec43(getStakedEventEncoder(), getStakedEventDecoder());
+function getVouchedEventCodec() {
+  return combineCodec48(getVouchedEventEncoder(), getVouchedEventDecoder());
 }
 
-// src/generated/types/stakeOutput.ts
+// src/generated/types/vouchOutput.ts
 import {
-  combineCodec as combineCodec44,
-  getStructDecoder as getStructDecoder38,
-  getStructEncoder as getStructEncoder38
+  combineCodec as combineCodec49,
+  getStructDecoder as getStructDecoder43,
+  getStructEncoder as getStructEncoder43
 } from "@solana/kit";
-function getStakeOutputEncoder() {
-  return getStructEncoder38([["field0", getStakeOutputStruct0Encoder()]]);
+function getVouchOutputEncoder() {
+  return getStructEncoder43([["field0", getVouchOutputStruct0Encoder()]]);
 }
-function getStakeOutputDecoder() {
-  return getStructDecoder38([["field0", getStakeOutputStruct0Decoder()]]);
+function getVouchOutputDecoder() {
+  return getStructDecoder43([["field0", getVouchOutputStruct0Decoder()]]);
 }
-function getStakeOutputCodec() {
-  return combineCodec44(getStakeOutputEncoder(), getStakeOutputDecoder());
+function getVouchOutputCodec() {
+  return combineCodec49(getVouchOutputEncoder(), getVouchOutputDecoder());
 }
 
-// src/generated/types/stakeOutputStruct0.ts
+// src/generated/types/vouchOutputStruct0.ts
 import {
-  combineCodec as combineCodec45,
-  getArrayDecoder as getArrayDecoder11,
-  getArrayEncoder as getArrayEncoder11,
-  getStructDecoder as getStructDecoder39,
-  getStructEncoder as getStructEncoder39,
+  combineCodec as combineCodec50,
+  getArrayDecoder as getArrayDecoder12,
+  getArrayEncoder as getArrayEncoder12,
+  getStructDecoder as getStructDecoder44,
+  getStructEncoder as getStructEncoder44,
   getU128Decoder as getU128Decoder3,
   getU128Encoder as getU128Encoder3,
-  getU8Decoder as getU8Decoder15,
-  getU8Encoder as getU8Encoder15
+  getU8Decoder as getU8Decoder16,
+  getU8Encoder as getU8Encoder16
 } from "@solana/kit";
-function getStakeOutputStruct0Encoder() {
-  return getStructEncoder39([
+function getVouchOutputStruct0Encoder() {
+  return getStructEncoder44([
     [
       "field0",
-      getStructEncoder39([
-        ["encryptionKey", getArrayEncoder11(getU8Encoder15(), { size: 32 })],
+      getStructEncoder44([
+        ["encryptionKey", getArrayEncoder12(getU8Encoder16(), { size: 32 })],
         ["nonce", getU128Encoder3()],
         [
           "ciphertexts",
-          getArrayEncoder11(getArrayEncoder11(getU8Encoder15(), { size: 32 }), {
+          getArrayEncoder12(getArrayEncoder12(getU8Encoder16(), { size: 32 }), {
             size: 1
           })
         ]
@@ -1828,12 +1999,12 @@ function getStakeOutputStruct0Encoder() {
     ],
     [
       "field1",
-      getStructEncoder39([
-        ["encryptionKey", getArrayEncoder11(getU8Encoder15(), { size: 32 })],
+      getStructEncoder44([
+        ["encryptionKey", getArrayEncoder12(getU8Encoder16(), { size: 32 })],
         ["nonce", getU128Encoder3()],
         [
           "ciphertexts",
-          getArrayEncoder11(getArrayEncoder11(getU8Encoder15(), { size: 32 }), {
+          getArrayEncoder12(getArrayEncoder12(getU8Encoder16(), { size: 32 }), {
             size: 1
           })
         ]
@@ -1841,16 +2012,16 @@ function getStakeOutputStruct0Encoder() {
     ]
   ]);
 }
-function getStakeOutputStruct0Decoder() {
-  return getStructDecoder39([
+function getVouchOutputStruct0Decoder() {
+  return getStructDecoder44([
     [
       "field0",
-      getStructDecoder39([
-        ["encryptionKey", getArrayDecoder11(getU8Decoder15(), { size: 32 })],
+      getStructDecoder44([
+        ["encryptionKey", getArrayDecoder12(getU8Decoder16(), { size: 32 })],
         ["nonce", getU128Decoder3()],
         [
           "ciphertexts",
-          getArrayDecoder11(getArrayDecoder11(getU8Decoder15(), { size: 32 }), {
+          getArrayDecoder12(getArrayDecoder12(getU8Decoder16(), { size: 32 }), {
             size: 1
           })
         ]
@@ -1858,12 +2029,12 @@ function getStakeOutputStruct0Decoder() {
     ],
     [
       "field1",
-      getStructDecoder39([
-        ["encryptionKey", getArrayDecoder11(getU8Decoder15(), { size: 32 })],
+      getStructDecoder44([
+        ["encryptionKey", getArrayDecoder12(getU8Decoder16(), { size: 32 })],
         ["nonce", getU128Decoder3()],
         [
           "ciphertexts",
-          getArrayDecoder11(getArrayDecoder11(getU8Decoder15(), { size: 32 }), {
+          getArrayDecoder12(getArrayDecoder12(getU8Decoder16(), { size: 32 }), {
             size: 1
           })
         ]
@@ -1871,309 +2042,141 @@ function getStakeOutputStruct0Decoder() {
     ]
   ]);
 }
-function getStakeOutputStruct0Codec() {
-  return combineCodec45(
-    getStakeOutputStruct0Encoder(),
-    getStakeOutputStruct0Decoder()
+function getVouchOutputStruct0Codec() {
+  return combineCodec50(
+    getVouchOutputStruct0Encoder(),
+    getVouchOutputStruct0Decoder()
   );
 }
 
-// src/generated/types/stakeParameters.ts
+// src/generated/types/vouchParameters.ts
 import {
-  combineCodec as combineCodec46,
-  getArrayDecoder as getArrayDecoder12,
-  getArrayEncoder as getArrayEncoder12,
-  getStructDecoder as getStructDecoder40,
-  getStructEncoder as getStructEncoder40,
+  combineCodec as combineCodec51,
+  getArrayDecoder as getArrayDecoder13,
+  getArrayEncoder as getArrayEncoder13,
+  getStructDecoder as getStructDecoder45,
+  getStructEncoder as getStructEncoder45,
   getU128Decoder as getU128Decoder4,
   getU128Encoder as getU128Encoder4,
-  getU32Decoder as getU32Decoder12,
-  getU32Encoder as getU32Encoder12,
-  getU64Decoder as getU64Decoder22,
-  getU64Encoder as getU64Encoder22,
-  getU8Decoder as getU8Decoder16,
-  getU8Encoder as getU8Encoder16
+  getU32Decoder as getU32Decoder13,
+  getU32Encoder as getU32Encoder13,
+  getU64Decoder as getU64Decoder25,
+  getU64Encoder as getU64Encoder25,
+  getU8Decoder as getU8Decoder17,
+  getU8Encoder as getU8Encoder17
 } from "@solana/kit";
-function getStakeParametersEncoder() {
-  return getStructEncoder40([
-    ["computationOffset", getU64Encoder22()],
-    ["stakeAccountId", getU32Encoder12()],
-    ["amount", getU64Encoder22()],
-    ["selectedOptionCiphertext", getArrayEncoder12(getU8Encoder16(), { size: 32 })],
+function getVouchParametersEncoder() {
+  return getStructEncoder45([
+    ["computationOffset", getU64Encoder25()],
+    ["vouchAccountId", getU32Encoder13()],
+    ["amount", getU64Encoder25()],
+    ["selectedOptionCiphertext", getArrayEncoder13(getU8Encoder17(), { size: 32 })],
     ["inputNonce", getU128Encoder4()],
     ["authorizedReaderNonce", getU128Encoder4()],
-    ["userPubkey", getArrayEncoder12(getU8Encoder16(), { size: 32 })],
+    ["userPubkey", getArrayEncoder13(getU8Encoder17(), { size: 32 })],
     ["stateNonce", getU128Encoder4()]
   ]);
 }
-function getStakeParametersDecoder() {
-  return getStructDecoder40([
-    ["computationOffset", getU64Decoder22()],
-    ["stakeAccountId", getU32Decoder12()],
-    ["amount", getU64Decoder22()],
-    ["selectedOptionCiphertext", getArrayDecoder12(getU8Decoder16(), { size: 32 })],
+function getVouchParametersDecoder() {
+  return getStructDecoder45([
+    ["computationOffset", getU64Decoder25()],
+    ["vouchAccountId", getU32Decoder13()],
+    ["amount", getU64Decoder25()],
+    ["selectedOptionCiphertext", getArrayDecoder13(getU8Decoder17(), { size: 32 })],
     ["inputNonce", getU128Decoder4()],
     ["authorizedReaderNonce", getU128Decoder4()],
-    ["userPubkey", getArrayDecoder12(getU8Decoder16(), { size: 32 })],
+    ["userPubkey", getArrayDecoder13(getU8Decoder17(), { size: 32 })],
     ["stateNonce", getU128Decoder4()]
   ]);
 }
-function getStakeParametersCodec() {
-  return combineCodec46(getStakeParametersEncoder(), getStakeParametersDecoder());
+function getVouchParametersCodec() {
+  return combineCodec51(getVouchParametersEncoder(), getVouchParametersDecoder());
 }
 
-// src/generated/types/stakeRevealedEvent.ts
+// src/generated/types/vouchRevealedEvent.ts
 import {
-  combineCodec as combineCodec47,
-  getAddressDecoder as getAddressDecoder24,
-  getAddressEncoder as getAddressEncoder24,
-  getI64Decoder as getI64Decoder18,
-  getI64Encoder as getI64Encoder18,
-  getStructDecoder as getStructDecoder41,
-  getStructEncoder as getStructEncoder41,
-  getU32Decoder as getU32Decoder13,
-  getU32Encoder as getU32Encoder13,
-  getU64Decoder as getU64Decoder23,
-  getU64Encoder as getU64Encoder23
+  combineCodec as combineCodec52,
+  getAddressDecoder as getAddressDecoder27,
+  getAddressEncoder as getAddressEncoder27,
+  getI64Decoder as getI64Decoder20,
+  getI64Encoder as getI64Encoder20,
+  getStructDecoder as getStructDecoder46,
+  getStructEncoder as getStructEncoder46,
+  getU32Decoder as getU32Decoder14,
+  getU32Encoder as getU32Encoder14,
+  getU64Decoder as getU64Decoder26,
+  getU64Encoder as getU64Encoder26
 } from "@solana/kit";
-function getStakeRevealedEventEncoder() {
-  return getStructEncoder41([
-    ["user", getAddressEncoder24()],
-    ["market", getAddressEncoder24()],
-    ["stakeAccount", getAddressEncoder24()],
-    ["stakeAccountId", getU32Encoder13()],
-    ["stakeAmount", getU64Encoder23()],
-    ["selectedOption", getU64Encoder23()],
-    ["timestamp", getI64Encoder18()]
+function getVouchRevealedEventEncoder() {
+  return getStructEncoder46([
+    ["user", getAddressEncoder27()],
+    ["market", getAddressEncoder27()],
+    ["vouchAccount", getAddressEncoder27()],
+    ["vouchAccountId", getU32Encoder14()],
+    ["vouchAmount", getU64Encoder26()],
+    ["selectedOption", getU64Encoder26()],
+    ["timestamp", getI64Encoder20()]
   ]);
 }
-function getStakeRevealedEventDecoder() {
-  return getStructDecoder41([
-    ["user", getAddressDecoder24()],
-    ["market", getAddressDecoder24()],
-    ["stakeAccount", getAddressDecoder24()],
-    ["stakeAccountId", getU32Decoder13()],
-    ["stakeAmount", getU64Decoder23()],
-    ["selectedOption", getU64Decoder23()],
-    ["timestamp", getI64Decoder18()]
+function getVouchRevealedEventDecoder() {
+  return getStructDecoder46([
+    ["user", getAddressDecoder27()],
+    ["market", getAddressDecoder27()],
+    ["vouchAccount", getAddressDecoder27()],
+    ["vouchAccountId", getU32Decoder14()],
+    ["vouchAmount", getU64Decoder26()],
+    ["selectedOption", getU64Decoder26()],
+    ["timestamp", getI64Decoder20()]
   ]);
 }
-function getStakeRevealedEventCodec() {
-  return combineCodec47(
-    getStakeRevealedEventEncoder(),
-    getStakeRevealedEventDecoder()
+function getVouchRevealedEventCodec() {
+  return combineCodec52(
+    getVouchRevealedEventEncoder(),
+    getVouchRevealedEventDecoder()
   );
 }
 
-// src/generated/types/stuckStakeClosedEvent.ts
+// src/generated/types/vouchWithdrawnEvent.ts
 import {
-  combineCodec as combineCodec48,
-  getAddressDecoder as getAddressDecoder25,
-  getAddressEncoder as getAddressEncoder25,
-  getI64Decoder as getI64Decoder19,
-  getI64Encoder as getI64Encoder19,
-  getStructDecoder as getStructDecoder42,
-  getStructEncoder as getStructEncoder42,
-  getU32Decoder as getU32Decoder14,
-  getU32Encoder as getU32Encoder14,
-  getU64Decoder as getU64Decoder24,
-  getU64Encoder as getU64Encoder24
+  combineCodec as combineCodec53,
+  getAddressDecoder as getAddressDecoder28,
+  getAddressEncoder as getAddressEncoder28,
+  getI64Decoder as getI64Decoder21,
+  getI64Encoder as getI64Encoder21,
+  getStructDecoder as getStructDecoder47,
+  getStructEncoder as getStructEncoder47,
+  getU32Decoder as getU32Decoder15,
+  getU32Encoder as getU32Encoder15,
+  getU64Decoder as getU64Decoder27,
+  getU64Encoder as getU64Encoder27
 } from "@solana/kit";
-function getStuckStakeClosedEventEncoder() {
-  return getStructEncoder42([
-    ["owner", getAddressEncoder25()],
-    ["market", getAddressEncoder25()],
-    ["stakeAccount", getAddressEncoder25()],
-    ["stakeAccountId", getU32Encoder14()],
-    ["refundedAmount", getU64Encoder24()],
-    ["refundedPlatformFee", getU64Encoder24()],
-    ["refundedRewardPoolFee", getU64Encoder24()],
-    ["refundedCreatorFee", getU64Encoder24()],
-    ["timestamp", getI64Encoder19()]
+function getVouchWithdrawnEventEncoder() {
+  return getStructEncoder47([
+    ["owner", getAddressEncoder28()],
+    ["market", getAddressEncoder28()],
+    ["vouchAccount", getAddressEncoder28()],
+    ["vouchAccountId", getU32Encoder15()],
+    ["amount", getU64Encoder27()],
+    ["timestamp", getI64Encoder21()]
   ]);
 }
-function getStuckStakeClosedEventDecoder() {
-  return getStructDecoder42([
-    ["owner", getAddressDecoder25()],
-    ["market", getAddressDecoder25()],
-    ["stakeAccount", getAddressDecoder25()],
-    ["stakeAccountId", getU32Decoder14()],
-    ["refundedAmount", getU64Decoder24()],
-    ["refundedPlatformFee", getU64Decoder24()],
-    ["refundedRewardPoolFee", getU64Decoder24()],
-    ["refundedCreatorFee", getU64Decoder24()],
-    ["timestamp", getI64Decoder19()]
-  ]);
-}
-function getStuckStakeClosedEventCodec() {
-  return combineCodec48(
-    getStuckStakeClosedEventEncoder(),
-    getStuckStakeClosedEventDecoder()
-  );
-}
-
-// src/generated/types/timestamp.ts
-import {
-  combineCodec as combineCodec49,
-  getStructDecoder as getStructDecoder43,
-  getStructEncoder as getStructEncoder43,
-  getU64Decoder as getU64Decoder25,
-  getU64Encoder as getU64Encoder25
-} from "@solana/kit";
-function getTimestampEncoder() {
-  return getStructEncoder43([["timestamp", getU64Encoder25()]]);
-}
-function getTimestampDecoder() {
-  return getStructDecoder43([["timestamp", getU64Decoder25()]]);
-}
-function getTimestampCodec() {
-  return combineCodec49(getTimestampEncoder(), getTimestampDecoder());
-}
-
-// src/generated/types/unstakedEvent.ts
-import {
-  combineCodec as combineCodec50,
-  getAddressDecoder as getAddressDecoder26,
-  getAddressEncoder as getAddressEncoder26,
-  getI64Decoder as getI64Decoder20,
-  getI64Encoder as getI64Encoder20,
-  getStructDecoder as getStructDecoder44,
-  getStructEncoder as getStructEncoder44,
-  getU32Decoder as getU32Decoder15,
-  getU32Encoder as getU32Encoder15,
-  getU64Decoder as getU64Decoder26,
-  getU64Encoder as getU64Encoder26
-} from "@solana/kit";
-function getUnstakedEventEncoder() {
-  return getStructEncoder44([
-    ["owner", getAddressEncoder26()],
-    ["market", getAddressEncoder26()],
-    ["stakeAccount", getAddressEncoder26()],
-    ["stakeAccountId", getU32Encoder15()],
-    ["amount", getU64Encoder26()],
-    ["timestamp", getI64Encoder20()]
-  ]);
-}
-function getUnstakedEventDecoder() {
-  return getStructDecoder44([
-    ["owner", getAddressDecoder26()],
-    ["market", getAddressDecoder26()],
-    ["stakeAccount", getAddressDecoder26()],
-    ["stakeAccountId", getU32Decoder15()],
-    ["amount", getU64Decoder26()],
-    ["timestamp", getI64Decoder20()]
-  ]);
-}
-function getUnstakedEventCodec() {
-  return combineCodec50(getUnstakedEventEncoder(), getUnstakedEventDecoder());
-}
-
-// src/generated/types/updateAuthorityChangedEvent.ts
-import {
-  combineCodec as combineCodec51,
-  getAddressDecoder as getAddressDecoder27,
-  getAddressEncoder as getAddressEncoder27,
-  getI64Decoder as getI64Decoder21,
-  getI64Encoder as getI64Encoder21,
-  getStructDecoder as getStructDecoder45,
-  getStructEncoder as getStructEncoder45
-} from "@solana/kit";
-function getUpdateAuthorityChangedEventEncoder() {
-  return getStructEncoder45([
-    ["platformConfig", getAddressEncoder27()],
-    ["oldValue", getAddressEncoder27()],
-    ["newValue", getAddressEncoder27()],
-    ["timestamp", getI64Encoder21()]
-  ]);
-}
-function getUpdateAuthorityChangedEventDecoder() {
-  return getStructDecoder45([
-    ["platformConfig", getAddressDecoder27()],
-    ["oldValue", getAddressDecoder27()],
-    ["newValue", getAddressDecoder27()],
+function getVouchWithdrawnEventDecoder() {
+  return getStructDecoder47([
+    ["owner", getAddressDecoder28()],
+    ["market", getAddressDecoder28()],
+    ["vouchAccount", getAddressDecoder28()],
+    ["vouchAccountId", getU32Decoder15()],
+    ["amount", getU64Decoder27()],
     ["timestamp", getI64Decoder21()]
   ]);
 }
-function getUpdateAuthorityChangedEventCodec() {
-  return combineCodec51(
-    getUpdateAuthorityChangedEventEncoder(),
-    getUpdateAuthorityChangedEventDecoder()
-  );
-}
-
-// src/generated/types/updatePlatformParameters.ts
-import {
-  combineCodec as combineCodec52,
-  getAddressDecoder as getAddressDecoder28,
-  getAddressEncoder as getAddressEncoder28,
-  getOptionDecoder as getOptionDecoder5,
-  getOptionEncoder as getOptionEncoder5,
-  getStructDecoder as getStructDecoder46,
-  getStructEncoder as getStructEncoder46,
-  getU16Decoder as getU16Decoder6,
-  getU16Encoder as getU16Encoder6,
-  getU64Decoder as getU64Decoder27,
-  getU64Encoder as getU64Encoder27
-} from "@solana/kit";
-function getUpdatePlatformParametersEncoder() {
-  return getStructEncoder46([
-    ["platformFeeBp", getOptionEncoder5(getU16Encoder6())],
-    ["rewardPoolFeeBp", getOptionEncoder5(getU16Encoder6())],
-    ["creatorFeeBp", getOptionEncoder5(getU16Encoder6())],
-    ["revealAuthority", getOptionEncoder5(getAddressEncoder28())],
-    ["minTimeToStakeSeconds", getOptionEncoder5(getU64Encoder27())],
-    ["revealPeriodSeconds", getOptionEncoder5(getU64Encoder27())],
-    ["marketResolutionDeadlineSeconds", getOptionEncoder5(getU64Encoder27())]
-  ]);
-}
-function getUpdatePlatformParametersDecoder() {
-  return getStructDecoder46([
-    ["platformFeeBp", getOptionDecoder5(getU16Decoder6())],
-    ["rewardPoolFeeBp", getOptionDecoder5(getU16Decoder6())],
-    ["creatorFeeBp", getOptionDecoder5(getU16Decoder6())],
-    ["revealAuthority", getOptionDecoder5(getAddressDecoder28())],
-    ["minTimeToStakeSeconds", getOptionDecoder5(getU64Decoder27())],
-    ["revealPeriodSeconds", getOptionDecoder5(getU64Decoder27())],
-    ["marketResolutionDeadlineSeconds", getOptionDecoder5(getU64Decoder27())]
-  ]);
-}
-function getUpdatePlatformParametersCodec() {
-  return combineCodec52(
-    getUpdatePlatformParametersEncoder(),
-    getUpdatePlatformParametersDecoder()
+function getVouchWithdrawnEventCodec() {
+  return combineCodec53(
+    getVouchWithdrawnEventEncoder(),
+    getVouchWithdrawnEventDecoder()
   );
 }
 
-// src/generated/types/utilityPubkeys.ts
-import {
-  combineCodec as combineCodec53,
-  getArrayDecoder as getArrayDecoder13,
-  getArrayEncoder as getArrayEncoder13,
-  getStructDecoder as getStructDecoder47,
-  getStructEncoder as getStructEncoder47,
-  getU8Decoder as getU8Decoder17,
-  getU8Encoder as getU8Encoder17
-} from "@solana/kit";
-function getUtilityPubkeysEncoder() {
-  return getStructEncoder47([
-    ["x25519Pubkey", getArrayEncoder13(getU8Encoder17(), { size: 32 })],
-    ["ed25519VerifyingKey", getArrayEncoder13(getU8Encoder17(), { size: 32 })],
-    ["elgamalPubkey", getArrayEncoder13(getU8Encoder17(), { size: 32 })],
-    ["pubkeyValidityProof", getArrayEncoder13(getU8Encoder17(), { size: 64 })]
-  ]);
-}
-function getUtilityPubkeysDecoder() {
-  return getStructDecoder47([
-    ["x25519Pubkey", getArrayDecoder13(getU8Decoder17(), { size: 32 })],
-    ["ed25519VerifyingKey", getArrayDecoder13(getU8Decoder17(), { size: 32 })],
-    ["elgamalPubkey", getArrayDecoder13(getU8Decoder17(), { size: 32 })],
-    ["pubkeyValidityProof", getArrayDecoder13(getU8Decoder17(), { size: 64 })]
-  ]);
-}
-function getUtilityPubkeysCodec() {
-  return combineCodec53(getUtilityPubkeysEncoder(), getUtilityPubkeysDecoder());
-}
-
 // src/generated/types/winningOptionSetEvent.ts
 import {
   combineCodec as combineCodec54,
@@ -2242,7 +2245,7 @@ function getOpportunityMarketEncoder() {
       ["index", getU64Encoder29()],
       ["totalOptions", getU64Encoder29()],
       ["platform", getAddressEncoder30()],
-      ["stakingWindowEnd", getOptionEncoder6(getU64Encoder29())],
+      ["vouchingWindowEnd", getOptionEncoder6(getU64Encoder29())],
       ["resolvedAtTimestamp", getOptionEncoder6(getU64Encoder29())],
       ["winningOptionAllocation", getU16Encoder8()],
       ["winningOptionActiveBp", getU16Encoder8()],
@@ -2259,7 +2262,7 @@ function getOpportunityMarketEncoder() {
       ["marketResolutionDeadlineSeconds", getU64Encoder29()],
       ["revealPeriodSeconds", getU64Encoder29()],
       ["revealEnded", getBooleanEncoder4()],
-      ["minStakeAmount", getU64Encoder29()]
+      ["minVouchAmount", getU64Encoder29()]
     ]),
     (value) => ({ ...value, discriminator: OPPORTUNITY_MARKET_DISCRIMINATOR })
   );
@@ -2272,7 +2275,7 @@ function getOpportunityMarketDecoder() {
     ["index", getU64Decoder29()],
     ["totalOptions", getU64Decoder29()],
     ["platform", getAddressDecoder30()],
-    ["stakingWindowEnd", getOptionDecoder6(getU64Decoder29())],
+    ["vouchingWindowEnd", getOptionDecoder6(getU64Decoder29())],
     ["resolvedAtTimestamp", getOptionDecoder6(getU64Decoder29())],
     ["winningOptionAllocation", getU16Decoder8()],
     ["winningOptionActiveBp", getU16Decoder8()],
@@ -2289,7 +2292,7 @@ function getOpportunityMarketDecoder() {
     ["marketResolutionDeadlineSeconds", getU64Decoder29()],
     ["revealPeriodSeconds", getU64Decoder29()],
     ["revealEnded", getBooleanDecoder4()],
-    ["minStakeAmount", getU64Decoder29()]
+    ["minVouchAmount", getU64Decoder29()]
   ]);
 }
 function getOpportunityMarketCodec() {
@@ -2380,7 +2383,7 @@ function getOpportunityMarketOptionEncoder() {
       ["id", getU64Encoder30()],
       ["creator", getAddressEncoder31()],
       ["createdAt", getU64Encoder30()],
-      ["unclaimedStake", getU64Encoder30()],
+      ["unclaimedGrossVouch", getU64Encoder30()],
       ["totalScore", getU128Encoder5()],
       ["rewardBp", getU16Encoder9()],
       ["includedInActiveBp", getBooleanEncoder5()]
@@ -2398,7 +2401,7 @@ function getOpportunityMarketOptionDecoder() {
     ["id", getU64Decoder30()],
     ["creator", getAddressDecoder31()],
     ["createdAt", getU64Decoder30()],
-    ["unclaimedStake", getU64Decoder30()],
+    ["unclaimedGrossVouch", getU64Decoder30()],
     ["totalScore", getU128Decoder5()],
     ["rewardBp", getU16Decoder9()],
     ["includedInActiveBp", getBooleanDecoder5()]
@@ -2600,7 +2603,7 @@ function getPlatformConfigEncoder() {
       ["feeClaimAuthority", getAddressEncoder33()],
       ["feeRates", getFeeRatesEncoder()],
       ["marketResolutionDeadlineSeconds", getU64Encoder32()],
-      ["minTimeToStakeSeconds", getU64Encoder32()],
+      ["minTimeToVouchSeconds", getU64Encoder32()],
       ["revealAuthority", getAddressEncoder33()],
       ["revealPeriodSeconds", getU64Encoder32()]
     ]),
@@ -2616,7 +2619,7 @@ function getPlatformConfigDecoder() {
     ["feeClaimAuthority", getAddressDecoder33()],
     ["feeRates", getFeeRatesDecoder()],
     ["marketResolutionDeadlineSeconds", getU64Decoder32()],
-    ["minTimeToStakeSeconds", getU64Decoder32()],
+    ["minTimeToVouchSeconds", getU64Decoder32()],
     ["revealAuthority", getAddressDecoder33()],
     ["revealPeriodSeconds", getU64Decoder32()]
   ]);
@@ -2655,7 +2658,7 @@ async function fetchAllMaybePlatformConfig(rpc, addresses, config) {
   );
 }
 
-// src/generated/accounts/stakeAccount.ts
+// src/generated/accounts/vouchAccount.ts
 import {
   assertAccountExists as assertAccountExists7,
   assertAccountsExist as assertAccountsExist7,
@@ -2687,22 +2690,22 @@ import {
   getU8Encoder as getU8Encoder22,
   transformEncoder as transformEncoder7
 } from "@solana/kit";
-var STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
-  80,
-  158,
-  67,
-  124,
-  50,
-  189,
-  192,
-  255
+var VOUCH_ACCOUNT_DISCRIMINATOR = new Uint8Array([
+  165,
+  230,
+  131,
+  136,
+  184,
+  203,
+  66,
+  136
 ]);
-function getStakeAccountDiscriminatorBytes() {
+function getVouchAccountDiscriminatorBytes() {
   return fixEncoderSize7(getBytesEncoder7(), 8).encode(
-    STAKE_ACCOUNT_DISCRIMINATOR
+    VOUCH_ACCOUNT_DISCRIMINATOR
   );
 }
-function getStakeAccountEncoder() {
+function getVouchAccountEncoder() {
   return transformEncoder7(
     getStructEncoder53([
       ["discriminator", fixEncoderSize7(getBytesEncoder7(), 8)],
@@ -2717,21 +2720,22 @@ function getStakeAccountEncoder() {
         getArrayEncoder15(getU8Encoder22(), { size: 32 })
       ],
       ["stateNonceDisclosure", getU128Encoder6()],
-      ["stakedAtTimestamp", getOptionEncoder7(getU64Encoder33())],
-      ["unstakedAtTimestamp", getOptionEncoder7(getU64Encoder33())],
+      ["vouchedAtTimestamp", getOptionEncoder7(getU64Encoder33())],
+      ["vouchWithdrawnAtTimestamp", getOptionEncoder7(getU64Encoder33())],
       ["amount", getU64Encoder33()],
       ["collectedFees", getCollectedFeesEncoder()],
       ["revealedOption", getOptionEncoder7(getU64Encoder33())],
       ["score", getOptionEncoder7(getU64Encoder33())],
       ["rewardsClaimed", getBooleanEncoder6()],
       ["id", getU32Encoder17()],
-      ["pendingStakeComputation", getOptionEncoder7(getAddressEncoder34())],
-      ["pendingRevealComputation", getOptionEncoder7(getAddressEncoder34())]
+      ["pendingVouchComputation", getOptionEncoder7(getAddressEncoder34())],
+      ["pendingRevealComputation", getOptionEncoder7(getAddressEncoder34())],
+      ["lastRevealVouchAt", getU64Encoder33()]
     ]),
-    (value) => ({ ...value, discriminator: STAKE_ACCOUNT_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: VOUCH_ACCOUNT_DISCRIMINATOR })
   );
 }
-function getStakeAccountDecoder() {
+function getVouchAccountDecoder() {
   return getStructDecoder53([
     ["discriminator", fixDecoderSize7(getBytesDecoder7(), 8)],
     ["encryptedOption", getArrayDecoder15(getU8Decoder22(), { size: 32 })],
@@ -2745,44 +2749,45 @@ function getStakeAccountDecoder() {
       getArrayDecoder15(getU8Decoder22(), { size: 32 })
     ],
     ["stateNonceDisclosure", getU128Decoder6()],
-    ["stakedAtTimestamp", getOptionDecoder7(getU64Decoder33())],
-    ["unstakedAtTimestamp", getOptionDecoder7(getU64Decoder33())],
+    ["vouchedAtTimestamp", getOptionDecoder7(getU64Decoder33())],
+    ["vouchWithdrawnAtTimestamp", getOptionDecoder7(getU64Decoder33())],
     ["amount", getU64Decoder33()],
     ["collectedFees", getCollectedFeesDecoder()],
     ["revealedOption", getOptionDecoder7(getU64Decoder33())],
     ["score", getOptionDecoder7(getU64Decoder33())],
     ["rewardsClaimed", getBooleanDecoder6()],
     ["id", getU32Decoder17()],
-    ["pendingStakeComputation", getOptionDecoder7(getAddressDecoder34())],
-    ["pendingRevealComputation", getOptionDecoder7(getAddressDecoder34())]
+    ["pendingVouchComputation", getOptionDecoder7(getAddressDecoder34())],
+    ["pendingRevealComputation", getOptionDecoder7(getAddressDecoder34())],
+    ["lastRevealVouchAt", getU64Decoder33()]
   ]);
 }
-function getStakeAccountCodec() {
-  return combineCodec59(getStakeAccountEncoder(), getStakeAccountDecoder());
+function getVouchAccountCodec() {
+  return combineCodec59(getVouchAccountEncoder(), getVouchAccountDecoder());
 }
-function decodeStakeAccount(encodedAccount) {
+function decodeVouchAccount(encodedAccount) {
   return decodeAccount7(
     encodedAccount,
-    getStakeAccountDecoder()
+    getVouchAccountDecoder()
   );
 }
-async function fetchStakeAccount(rpc, address3, config) {
-  const maybeAccount = await fetchMaybeStakeAccount(rpc, address3, config);
+async function fetchVouchAccount(rpc, address3, config) {
+  const maybeAccount = await fetchMaybeVouchAccount(rpc, address3, config);
   assertAccountExists7(maybeAccount);
   return maybeAccount;
 }
-async function fetchMaybeStakeAccount(rpc, address3, config) {
+async function fetchMaybeVouchAccount(rpc, address3, config) {
   const maybeAccount = await fetchEncodedAccount7(rpc, address3, config);
-  return decodeStakeAccount(maybeAccount);
+  return decodeVouchAccount(maybeAccount);
 }
-async function fetchAllStakeAccount(rpc, addresses, config) {
-  const maybeAccounts = await fetchAllMaybeStakeAccount(rpc, addresses, config);
+async function fetchAllVouchAccount(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeVouchAccount(rpc, addresses, config);
   assertAccountsExist7(maybeAccounts);
   return maybeAccounts;
 }
-async function fetchAllMaybeStakeAccount(rpc, addresses, config) {
+async function fetchAllMaybeVouchAccount(rpc, addresses, config) {
   const maybeAccounts = await fetchEncodedAccounts7(rpc, addresses, config);
-  return maybeAccounts.map((maybeAccount) => decodeStakeAccount(maybeAccount));
+  return maybeAccounts.map((maybeAccount) => decodeVouchAccount(maybeAccount));
 }
 
 // src/generated/errors/opportunityMarket.ts
@@ -2804,7 +2809,7 @@ var OpportunityMarketAccount = /* @__PURE__ */ ((OpportunityMarketAccount2) => {
   OpportunityMarketAccount2[OpportunityMarketAccount2["OpportunityMarketOption"] = 3] = "OpportunityMarketOption";
   OpportunityMarketAccount2[OpportunityMarketAccount2["OpportunityMarketSponsor"] = 4] = "OpportunityMarketSponsor";
   OpportunityMarketAccount2[OpportunityMarketAccount2["PlatformConfig"] = 5] = "PlatformConfig";
-  OpportunityMarketAccount2[OpportunityMarketAccount2["StakeAccount"] = 6] = "StakeAccount";
+  OpportunityMarketAccount2[OpportunityMarketAccount2["VouchAccount"] = 6] = "VouchAccount";
   return OpportunityMarketAccount2;
 })(OpportunityMarketAccount || {});
 function identifyOpportunityMarketAccount(account) {
@@ -2866,11 +2871,11 @@ function identifyOpportunityMarketAccount(account) {
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([80, 158, 67, 124, 50, 189, 192, 255])
+      new Uint8Array([165, 230, 131, 136, 184, 203, 66, 136])
     ),
     0
   )) {
-    return 6 /* StakeAccount */;
+    return 6 /* VouchAccount */;
   }
   throw new Error(
     "The provided account could not be identified as a opportunityMarket account."
@@ -2883,29 +2888,29 @@ var OpportunityMarketInstruction = /* @__PURE__ */ ((OpportunityMarketInstructio
   OpportunityMarketInstruction2[OpportunityMarketInstruction2["ClaimFees"] = 3] = "ClaimFees";
   OpportunityMarketInstruction2[OpportunityMarketInstruction2["ClaimRewards"] = 4] = "ClaimRewards";
   OpportunityMarketInstruction2[OpportunityMarketInstruction2["CloseOptionAccount"] = 5] = "CloseOptionAccount";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["CloseStakeAccount"] = 6] = "CloseStakeAccount";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["CloseStuckStakeAccount"] = 7] = "CloseStuckStakeAccount";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["CloseUnrevealedStakeAccount"] = 8] = "CloseUnrevealedStakeAccount";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["CloseStuckVouchAccount"] = 6] = "CloseStuckVouchAccount";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["CloseUnrevealedVouchAccount"] = 7] = "CloseUnrevealedVouchAccount";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["CloseVouchAccount"] = 8] = "CloseVouchAccount";
   OpportunityMarketInstruction2[OpportunityMarketInstruction2["CreateMarket"] = 9] = "CreateMarket";
   OpportunityMarketInstruction2[OpportunityMarketInstruction2["EndRevealPeriod"] = 10] = "EndRevealPeriod";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["FinalizeRevealStake"] = 11] = "FinalizeRevealStake";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["FinalizeRevealVouch"] = 11] = "FinalizeRevealVouch";
   OpportunityMarketInstruction2[OpportunityMarketInstruction2["InitAllowedMint"] = 12] = "InitAllowedMint";
   OpportunityMarketInstruction2[OpportunityMarketInstruction2["InitPlatformConfig"] = 13] = "InitPlatformConfig";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["InitStakeAccount"] = 14] = "InitStakeAccount";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["InitVouchAccount"] = 14] = "InitVouchAccount";
   OpportunityMarketInstruction2[OpportunityMarketInstruction2["OpenMarket"] = 15] = "OpenMarket";
   OpportunityMarketInstruction2[OpportunityMarketInstruction2["ResolveMarket"] = 16] = "ResolveMarket";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealStake"] = 17] = "RevealStake";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealStakeCallback"] = 18] = "RevealStakeCallback";
-  OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealStakeCompDef"] = 19] = "RevealStakeCompDef";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealVouch"] = 17] = "RevealVouch";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealVouchCallback"] = 18] = "RevealVouchCallback";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["RevealVouchCompDef"] = 19] = "RevealVouchCompDef";
   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["UpdatePlatformConfig"] = 23] = "UpdatePlatformConfig";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["Vouch"] = 24] = "Vouch";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["VouchCallback"] = 25] = "VouchCallback";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["VouchCompDef"] = 26] = "VouchCompDef";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["WithdrawReward"] = 27] = "WithdrawReward";
+  OpportunityMarketInstruction2[OpportunityMarketInstruction2["WithdrawVouch"] = 28] = "WithdrawVouch";
   return OpportunityMarketInstruction2;
 })(OpportunityMarketInstruction || {});
 function identifyOpportunityMarketInstruction(instruction) {
@@ -2967,29 +2972,29 @@ function identifyOpportunityMarketInstruction(instruction) {
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([246, 236, 59, 167, 115, 135, 122, 12])
+      new Uint8Array([27, 238, 197, 24, 57, 59, 252, 18])
     ),
     0
   )) {
-    return 6 /* CloseStakeAccount */;
+    return 6 /* CloseStuckVouchAccount */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([41, 239, 108, 203, 185, 230, 165, 181])
+      new Uint8Array([192, 236, 224, 245, 5, 49, 188, 11])
     ),
     0
   )) {
-    return 7 /* CloseStuckStakeAccount */;
+    return 7 /* CloseUnrevealedVouchAccount */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([171, 229, 236, 216, 122, 118, 188, 103])
+      new Uint8Array([107, 196, 52, 68, 9, 214, 207, 109])
     ),
     0
   )) {
-    return 8 /* CloseUnrevealedStakeAccount */;
+    return 8 /* CloseVouchAccount */;
   }
   if (containsBytes(
     data,
@@ -3012,11 +3017,11 @@ function identifyOpportunityMarketInstruction(instruction) {
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([92, 201, 94, 219, 117, 53, 255, 230])
+      new Uint8Array([1, 34, 40, 131, 236, 85, 1, 25])
     ),
     0
   )) {
-    return 11 /* FinalizeRevealStake */;
+    return 11 /* FinalizeRevealVouch */;
   }
   if (containsBytes(
     data,
@@ -3039,11 +3044,11 @@ function identifyOpportunityMarketInstruction(instruction) {
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([132, 171, 255, 149, 163, 37, 220, 45])
+      new Uint8Array([170, 190, 149, 246, 116, 216, 171, 230])
     ),
     0
   )) {
-    return 14 /* InitStakeAccount */;
+    return 14 /* InitVouchAccount */;
   }
   if (containsBytes(
     data,
@@ -3066,29 +3071,29 @@ function identifyOpportunityMarketInstruction(instruction) {
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([107, 229, 210, 77, 126, 255, 243, 188])
+      new Uint8Array([137, 238, 214, 30, 51, 142, 141, 105])
     ),
     0
   )) {
-    return 17 /* RevealStake */;
+    return 17 /* RevealVouch */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([79, 19, 120, 162, 232, 39, 206, 116])
+      new Uint8Array([251, 246, 6, 118, 139, 46, 136, 190])
     ),
     0
   )) {
-    return 18 /* RevealStakeCallback */;
+    return 18 /* RevealVouchCallback */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([197, 20, 216, 132, 43, 99, 64, 0])
+      new Uint8Array([176, 228, 5, 47, 19, 6, 243, 236])
     ),
     0
   )) {
-    return 19 /* RevealStakeCompDef */;
+    return 19 /* RevealVouchCompDef */;
   }
   if (containsBytes(
     data,
@@ -3120,56 +3125,56 @@ function identifyOpportunityMarketInstruction(instruction) {
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([206, 176, 202, 18, 200, 209, 179, 108])
+      new Uint8Array([195, 60, 76, 129, 146, 45, 67, 143])
     ),
     0
   )) {
-    return 23 /* Stake */;
+    return 23 /* UpdatePlatformConfig */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([40, 220, 36, 47, 6, 116, 132, 89])
+      new Uint8Array([87, 240, 8, 21, 219, 179, 242, 177])
     ),
     0
   )) {
-    return 24 /* StakeCallback */;
+    return 24 /* Vouch */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([156, 5, 60, 126, 142, 149, 1, 130])
+      new Uint8Array([10, 0, 52, 15, 179, 148, 194, 135])
     ),
     0
   )) {
-    return 25 /* StakeCompDef */;
+    return 25 /* VouchCallback */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([90, 95, 107, 42, 205, 124, 50, 225])
+      new Uint8Array([138, 27, 95, 181, 9, 219, 232, 219])
     ),
     0
   )) {
-    return 26 /* Unstake */;
+    return 26 /* VouchCompDef */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([195, 60, 76, 129, 146, 45, 67, 143])
+      new Uint8Array([191, 187, 176, 137, 9, 25, 187, 244])
     ),
     0
   )) {
-    return 27 /* UpdatePlatformConfig */;
+    return 27 /* WithdrawReward */;
   }
   if (containsBytes(
     data,
     fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([191, 187, 176, 137, 9, 25, 187, 244])
+      new Uint8Array([201, 33, 64, 226, 252, 193, 27, 83])
     ),
     0
   )) {
-    return 28 /* WithdrawReward */;
+    return 28 /* WithdrawVouch */;
   }
   throw new Error(
     "The provided instruction could not be identified as a opportunityMarket instruction."
@@ -3182,20 +3187,20 @@ var OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_BALANCE = 6001;
 var OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_REWARD_FUNDING = 6002;
 var OPPORTUNITY_MARKET_ERROR__INVALID_PARAMETERS = 6003;
 var OPPORTUNITY_MARKET_ERROR__INVALID_OPTION_ID = 6004;
-var OPPORTUNITY_MARKET_ERROR__NO_STAKE = 6005;
+var OPPORTUNITY_MARKET_ERROR__NO_VOUCH = 6005;
 var OPPORTUNITY_MARKET_ERROR__WINNER_ALREADY_SELECTED = 6006;
 var OPPORTUNITY_MARKET_ERROR__ALREADY_REVEALED = 6007;
 var OPPORTUNITY_MARKET_ERROR__NOT_REVEALED = 6008;
 var OPPORTUNITY_MARKET_ERROR__TALLY_ALREADY_INCREMENTED = 6009;
 var OPPORTUNITY_MARKET_ERROR__OVERFLOW = 6010;
 var OPPORTUNITY_MARKET_ERROR__INVALID_MINT = 6011;
-var OPPORTUNITY_MARKET_ERROR__ALREADY_UNSTAKED = 6012;
-var OPPORTUNITY_MARKET_ERROR__ALREADY_STAKED = 6013;
+var OPPORTUNITY_MARKET_ERROR__ALREADY_VOUCH_WITHDRAWN = 6012;
+var OPPORTUNITY_MARKET_ERROR__ALREADY_VOUCHED = 6013;
 var OPPORTUNITY_MARKET_ERROR__LOCKED = 6014;
 var OPPORTUNITY_MARKET_ERROR__INVALID_ACCOUNT_STATE = 6015;
 var OPPORTUNITY_MARKET_ERROR__NO_FEES_TO_CLAIM = 6016;
-var OPPORTUNITY_MARKET_ERROR__STAKE_NOT_STUCK = 6017;
-var OPPORTUNITY_MARKET_ERROR__STAKE_BELOW_MINIMUM = 6018;
+var OPPORTUNITY_MARKET_ERROR__VOUCH_NOT_STUCK = 6017;
+var OPPORTUNITY_MARKET_ERROR__VOUCH_BELOW_MINIMUM = 6018;
 var OPPORTUNITY_MARKET_ERROR__INVALID_FEE_RATES = 6019;
 var OPPORTUNITY_MARKET_ERROR__OPTION_STILL_NEEDED = 6020;
 var OPPORTUNITY_MARKET_ERROR__CREATOR_MISMATCH = 6021;
@@ -3206,9 +3211,9 @@ var OPPORTUNITY_MARKET_ERROR__WRONG_MARKET_PHASE = 6025;
 var opportunityMarketErrorMessages;
 if (process.env.NODE_ENV !== "production") {
   opportunityMarketErrorMessages = {
-    [OPPORTUNITY_MARKET_ERROR__ALREADY_REVEALED]: `Stake already revealed`,
-    [OPPORTUNITY_MARKET_ERROR__ALREADY_STAKED]: `Already staked for this stake account`,
-    [OPPORTUNITY_MARKET_ERROR__ALREADY_UNSTAKED]: `Already unstaked`,
+    [OPPORTUNITY_MARKET_ERROR__ALREADY_REVEALED]: `Vouch already revealed`,
+    [OPPORTUNITY_MARKET_ERROR__ALREADY_VOUCHED]: `Already vouched for this vouch account`,
+    [OPPORTUNITY_MARKET_ERROR__ALREADY_VOUCH_WITHDRAWN]: `Vouch already withdrawn`,
     [OPPORTUNITY_MARKET_ERROR__CREATOR_MISMATCH]: `Creator mismatch`,
     [OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_BALANCE]: `Insufficient balance`,
     [OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_REWARD_FUNDING]: `Insufficient reward funding`,
@@ -3219,17 +3224,17 @@ if (process.env.NODE_ENV !== "production") {
     [OPPORTUNITY_MARKET_ERROR__INVALID_PARAMETERS]: `Invalid parameters`,
     [OPPORTUNITY_MARKET_ERROR__LOCKED]: `Account is locked`,
     [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_FINALIZED_WINNING_OPTION]: `No winning option has a finalized vouch`,
     [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`,
+    [OPPORTUNITY_MARKET_ERROR__NOT_REVEALED]: `Vouch not yet revealed`,
+    [OPPORTUNITY_MARKET_ERROR__NO_VOUCH]: `Vouch account has no recorded vouch`,
     [OPPORTUNITY_MARKET_ERROR__OPTION_STILL_NEEDED]: `Option still needed`,
     [OPPORTUNITY_MARKET_ERROR__OVERFLOW]: `Arithmetic overflow`,
     [OPPORTUNITY_MARKET_ERROR__REWARD_ALREADY_CLAIMED]: `Reward already claimed`,
-    [OPPORTUNITY_MARKET_ERROR__STAKE_BELOW_MINIMUM]: `Stake amount is below the market minimum`,
-    [OPPORTUNITY_MARKET_ERROR__STAKE_NOT_STUCK]: `Stake account is not in a stuck or failed state`,
-    [OPPORTUNITY_MARKET_ERROR__TALLY_ALREADY_INCREMENTED]: `Tally already incremented for this stake account`,
+    [OPPORTUNITY_MARKET_ERROR__TALLY_ALREADY_INCREMENTED]: `Tally already incremented for this vouch account`,
     [OPPORTUNITY_MARKET_ERROR__UNAUTHORIZED]: `Unauthorized`,
+    [OPPORTUNITY_MARKET_ERROR__VOUCH_BELOW_MINIMUM]: `Vouch amount is below the market minimum`,
+    [OPPORTUNITY_MARKET_ERROR__VOUCH_NOT_STUCK]: `Vouch account is not in a stuck or failed state`,
     [OPPORTUNITY_MARKET_ERROR__WINNER_ALREADY_SELECTED]: `Market winner already selected`,
     [OPPORTUNITY_MARKET_ERROR__WRONG_MARKET_PHASE]: `Operation is not permitted in the current market phase`
   };
@@ -3932,7 +3937,7 @@ async function getClaimRewardsInstructionAsync(input, config) {
   const originalAccounts = {
     owner: { value: input.owner ?? null, isWritable: true },
     market: { value: input.market ?? null, isWritable: true },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true },
     option: { value: input.option ?? null, isWritable: true },
     tokenMint: { value: input.tokenMint ?? null, isWritable: false },
     marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
@@ -3958,7 +3963,7 @@ async function getClaimRewardsInstructionAsync(input, config) {
     accounts: [
       getAccountMeta(accounts.owner),
       getAccountMeta(accounts.market),
-      getAccountMeta(accounts.stakeAccount),
+      getAccountMeta(accounts.vouchAccount),
       getAccountMeta(accounts.option),
       getAccountMeta(accounts.tokenMint),
       getAccountMeta(accounts.marketTokenAta),
@@ -3974,7 +3979,7 @@ function getClaimRewardsInstruction(input, config) {
   const originalAccounts = {
     owner: { value: input.owner ?? null, isWritable: true },
     market: { value: input.market ?? null, isWritable: true },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true },
     option: { value: input.option ?? null, isWritable: true },
     tokenMint: { value: input.tokenMint ?? null, isWritable: false },
     marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
@@ -3990,7 +3995,7 @@ function getClaimRewardsInstruction(input, config) {
     accounts: [
       getAccountMeta(accounts.owner),
       getAccountMeta(accounts.market),
-      getAccountMeta(accounts.stakeAccount),
+      getAccountMeta(accounts.vouchAccount),
       getAccountMeta(accounts.option),
       getAccountMeta(accounts.tokenMint),
       getAccountMeta(accounts.marketTokenAta),
@@ -4016,7 +4021,7 @@ function parseClaimRewardsInstruction(instruction) {
     accounts: {
       owner: getNextAccount(),
       market: getNextAccount(),
-      stakeAccount: getNextAccount(),
+      vouchAccount: getNextAccount(),
       option: getNextAccount(),
       tokenMint: getNextAccount(),
       marketTokenAta: getNextAccount(),
@@ -4173,7 +4178,7 @@ function parseCloseOptionAccountInstruction(instruction) {
   };
 }
 
-// src/generated/instructions/closeStakeAccount.ts
+// src/generated/instructions/closeStuckVouchAccount.ts
 import {
   combineCodec as combineCodec66,
   fixDecoderSize as fixDecoderSize14,
@@ -4184,57 +4189,93 @@ import {
   getProgramDerivedAddress as getProgramDerivedAddress7,
   getStructDecoder as getStructDecoder60,
   getStructEncoder as getStructEncoder60,
+  getU32Decoder as getU32Decoder18,
+  getU32Encoder as getU32Encoder18,
   transformEncoder as transformEncoder14
 } from "@solana/kit";
-var CLOSE_STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
-  246,
-  236,
+var CLOSE_STUCK_VOUCH_ACCOUNT_DISCRIMINATOR = new Uint8Array([
+  27,
+  238,
+  197,
+  24,
+  57,
   59,
-  167,
-  115,
-  135,
-  122,
-  12
+  252,
+  18
 ]);
-function getCloseStakeAccountDiscriminatorBytes() {
+function getCloseStuckVouchAccountDiscriminatorBytes() {
   return fixEncoderSize15(getBytesEncoder15(), 8).encode(
-    CLOSE_STAKE_ACCOUNT_DISCRIMINATOR
+    CLOSE_STUCK_VOUCH_ACCOUNT_DISCRIMINATOR
   );
 }
-function getCloseStakeAccountInstructionDataEncoder() {
+function getCloseStuckVouchAccountInstructionDataEncoder() {
   return transformEncoder14(
-    getStructEncoder60([["discriminator", fixEncoderSize15(getBytesEncoder15(), 8)]]),
-    (value) => ({ ...value, discriminator: CLOSE_STAKE_ACCOUNT_DISCRIMINATOR })
+    getStructEncoder60([
+      ["discriminator", fixEncoderSize15(getBytesEncoder15(), 8)],
+      ["vouchAccountId", getU32Encoder18()]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: CLOSE_STUCK_VOUCH_ACCOUNT_DISCRIMINATOR
+    })
   );
 }
-function getCloseStakeAccountInstructionDataDecoder() {
+function getCloseStuckVouchAccountInstructionDataDecoder() {
   return getStructDecoder60([
-    ["discriminator", fixDecoderSize14(getBytesDecoder14(), 8)]
+    ["discriminator", fixDecoderSize14(getBytesDecoder14(), 8)],
+    ["vouchAccountId", getU32Decoder18()]
   ]);
 }
-function getCloseStakeAccountInstructionDataCodec() {
+function getCloseStuckVouchAccountInstructionDataCodec() {
   return combineCodec66(
-    getCloseStakeAccountInstructionDataEncoder(),
-    getCloseStakeAccountInstructionDataDecoder()
+    getCloseStuckVouchAccountInstructionDataEncoder(),
+    getCloseStuckVouchAccountInstructionDataDecoder()
   );
 }
-async function getCloseStakeAccountInstructionAsync(input, config) {
+async function getCloseStuckVouchAccountInstructionAsync(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
-    owner: { value: input.owner ?? null, isWritable: true },
-    market: { value: input.market ?? null, isWritable: true },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
-    option: { value: input.option ?? null, isWritable: true },
+    signer: { value: input.signer ?? null, isWritable: true },
+    market: { value: input.market ?? null, isWritable: false },
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true },
     tokenMint: { value: input.tokenMint ?? null, isWritable: false },
-    marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
-    ownerTokenAccount: {
-      value: input.ownerTokenAccount ?? null,
+    signerTokenAccount: {
+      value: input.signerTokenAccount ?? null,
       isWritable: true
     },
+    marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
     tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
     systemProgram: { value: input.systemProgram ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.vouchAccount.value) {
+    accounts.vouchAccount.value = await getProgramDerivedAddress7({
+      programAddress,
+      seeds: [
+        getBytesEncoder15().encode(
+          new Uint8Array([
+            118,
+            111,
+            117,
+            99,
+            104,
+            95,
+            97,
+            99,
+            99,
+            111,
+            117,
+            110,
+            116
+          ])
+        ),
+        getAddressEncoder41().encode(expectAddress(accounts.signer.value)),
+        getAddressEncoder41().encode(expectAddress(accounts.market.value)),
+        getU32Encoder18().encode(expectSome(args.vouchAccountId))
+      ]
+    });
+  }
   if (!accounts.marketTokenAta.value) {
     accounts.marketTokenAta.value = await getProgramDerivedAddress7({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
@@ -4251,59 +4292,61 @@ async function getCloseStakeAccountInstructionAsync(input, config) {
   const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
   return Object.freeze({
     accounts: [
-      getAccountMeta(accounts.owner),
+      getAccountMeta(accounts.signer),
       getAccountMeta(accounts.market),
-      getAccountMeta(accounts.stakeAccount),
-      getAccountMeta(accounts.option),
+      getAccountMeta(accounts.vouchAccount),
       getAccountMeta(accounts.tokenMint),
+      getAccountMeta(accounts.signerTokenAccount),
       getAccountMeta(accounts.marketTokenAta),
-      getAccountMeta(accounts.ownerTokenAccount),
       getAccountMeta(accounts.tokenProgram),
       getAccountMeta(accounts.systemProgram)
     ],
-    data: getCloseStakeAccountInstructionDataEncoder().encode({}),
+    data: getCloseStuckVouchAccountInstructionDataEncoder().encode(
+      args
+    ),
     programAddress
   });
 }
-function getCloseStakeAccountInstruction(input, config) {
+function getCloseStuckVouchAccountInstruction(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
-    owner: { value: input.owner ?? null, isWritable: true },
-    market: { value: input.market ?? null, isWritable: true },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
-    option: { value: input.option ?? null, isWritable: true },
+    signer: { value: input.signer ?? null, isWritable: true },
+    market: { value: input.market ?? null, isWritable: false },
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true },
     tokenMint: { value: input.tokenMint ?? null, isWritable: false },
-    marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
-    ownerTokenAccount: {
-      value: input.ownerTokenAccount ?? null,
+    signerTokenAccount: {
+      value: input.signerTokenAccount ?? null,
       isWritable: true
     },
+    marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
     tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
     systemProgram: { value: input.systemProgram ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
+  const args = { ...input };
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
   const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
   return Object.freeze({
     accounts: [
-      getAccountMeta(accounts.owner),
+      getAccountMeta(accounts.signer),
       getAccountMeta(accounts.market),
-      getAccountMeta(accounts.stakeAccount),
-      getAccountMeta(accounts.option),
+      getAccountMeta(accounts.vouchAccount),
       getAccountMeta(accounts.tokenMint),
+      getAccountMeta(accounts.signerTokenAccount),
       getAccountMeta(accounts.marketTokenAta),
-      getAccountMeta(accounts.ownerTokenAccount),
       getAccountMeta(accounts.tokenProgram),
       getAccountMeta(accounts.systemProgram)
     ],
-    data: getCloseStakeAccountInstructionDataEncoder().encode({}),
+    data: getCloseStuckVouchAccountInstructionDataEncoder().encode(
+      args
+    ),
     programAddress
   });
 }
-function parseCloseStakeAccountInstruction(instruction) {
-  if (instruction.accounts.length < 9) {
+function parseCloseStuckVouchAccountInstruction(instruction) {
+  if (instruction.accounts.length < 8) {
     throw new Error("Not enough accounts");
   }
   let accountIndex = 0;
@@ -4315,21 +4358,22 @@ function parseCloseStakeAccountInstruction(instruction) {
   return {
     programAddress: instruction.programAddress,
     accounts: {
-      owner: getNextAccount(),
+      signer: getNextAccount(),
       market: getNextAccount(),
-      stakeAccount: getNextAccount(),
-      option: getNextAccount(),
+      vouchAccount: getNextAccount(),
       tokenMint: getNextAccount(),
+      signerTokenAccount: getNextAccount(),
       marketTokenAta: getNextAccount(),
-      ownerTokenAccount: getNextAccount(),
       tokenProgram: getNextAccount(),
       systemProgram: getNextAccount()
     },
-    data: getCloseStakeAccountInstructionDataDecoder().decode(instruction.data)
+    data: getCloseStuckVouchAccountInstructionDataDecoder().decode(
+      instruction.data
+    )
   };
 }
 
-// src/generated/instructions/closeStuckStakeAccount.ts
+// src/generated/instructions/closeUnrevealedVouchAccount.ts
 import {
   combineCodec as combineCodec67,
   fixDecoderSize as fixDecoderSize15,
@@ -4340,93 +4384,59 @@ import {
   getProgramDerivedAddress as getProgramDerivedAddress8,
   getStructDecoder as getStructDecoder61,
   getStructEncoder as getStructEncoder61,
-  getU32Decoder as getU32Decoder18,
-  getU32Encoder as getU32Encoder18,
   transformEncoder as transformEncoder15
 } from "@solana/kit";
-var CLOSE_STUCK_STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
-  41,
-  239,
-  108,
-  203,
-  185,
-  230,
-  165,
-  181
+var CLOSE_UNREVEALED_VOUCH_ACCOUNT_DISCRIMINATOR = new Uint8Array([
+  192,
+  236,
+  224,
+  245,
+  5,
+  49,
+  188,
+  11
 ]);
-function getCloseStuckStakeAccountDiscriminatorBytes() {
+function getCloseUnrevealedVouchAccountDiscriminatorBytes() {
   return fixEncoderSize16(getBytesEncoder16(), 8).encode(
-    CLOSE_STUCK_STAKE_ACCOUNT_DISCRIMINATOR
+    CLOSE_UNREVEALED_VOUCH_ACCOUNT_DISCRIMINATOR
   );
 }
-function getCloseStuckStakeAccountInstructionDataEncoder() {
+function getCloseUnrevealedVouchAccountInstructionDataEncoder() {
   return transformEncoder15(
-    getStructEncoder61([
-      ["discriminator", fixEncoderSize16(getBytesEncoder16(), 8)],
-      ["stakeAccountId", getU32Encoder18()]
-    ]),
+    getStructEncoder61([["discriminator", fixEncoderSize16(getBytesEncoder16(), 8)]]),
     (value) => ({
       ...value,
-      discriminator: CLOSE_STUCK_STAKE_ACCOUNT_DISCRIMINATOR
+      discriminator: CLOSE_UNREVEALED_VOUCH_ACCOUNT_DISCRIMINATOR
     })
   );
 }
-function getCloseStuckStakeAccountInstructionDataDecoder() {
+function getCloseUnrevealedVouchAccountInstructionDataDecoder() {
   return getStructDecoder61([
-    ["discriminator", fixDecoderSize15(getBytesDecoder15(), 8)],
-    ["stakeAccountId", getU32Decoder18()]
+    ["discriminator", fixDecoderSize15(getBytesDecoder15(), 8)]
   ]);
 }
-function getCloseStuckStakeAccountInstructionDataCodec() {
+function getCloseUnrevealedVouchAccountInstructionDataCodec() {
   return combineCodec67(
-    getCloseStuckStakeAccountInstructionDataEncoder(),
-    getCloseStuckStakeAccountInstructionDataDecoder()
+    getCloseUnrevealedVouchAccountInstructionDataEncoder(),
+    getCloseUnrevealedVouchAccountInstructionDataDecoder()
   );
 }
-async function getCloseStuckStakeAccountInstructionAsync(input, config) {
+async function getCloseUnrevealedVouchAccountInstructionAsync(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
-    signer: { value: input.signer ?? null, isWritable: true },
-    market: { value: input.market ?? null, isWritable: false },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
+    owner: { value: input.owner ?? null, isWritable: true },
+    market: { value: input.market ?? null, isWritable: true },
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true },
     tokenMint: { value: input.tokenMint ?? null, isWritable: false },
-    signerTokenAccount: {
-      value: input.signerTokenAccount ?? null,
+    marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
+    ownerTokenAccount: {
+      value: input.ownerTokenAccount ?? null,
       isWritable: true
     },
-    marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
     tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
     systemProgram: { value: input.systemProgram ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
-  const args = { ...input };
-  if (!accounts.stakeAccount.value) {
-    accounts.stakeAccount.value = await getProgramDerivedAddress8({
-      programAddress,
-      seeds: [
-        getBytesEncoder16().encode(
-          new Uint8Array([
-            115,
-            116,
-            97,
-            107,
-            101,
-            95,
-            97,
-            99,
-            99,
-            111,
-            117,
-            110,
-            116
-          ])
-        ),
-        getAddressEncoder42().encode(expectAddress(accounts.signer.value)),
-        getAddressEncoder42().encode(expectAddress(accounts.market.value)),
-        getU32Encoder18().encode(expectSome(args.stakeAccountId))
-      ]
-    });
-  }
   if (!accounts.marketTokenAta.value) {
     accounts.marketTokenAta.value = await getProgramDerivedAddress8({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
@@ -4443,60 +4453,55 @@ async function getCloseStuckStakeAccountInstructionAsync(input, config) {
   const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
   return Object.freeze({
     accounts: [
-      getAccountMeta(accounts.signer),
+      getAccountMeta(accounts.owner),
       getAccountMeta(accounts.market),
-      getAccountMeta(accounts.stakeAccount),
+      getAccountMeta(accounts.vouchAccount),
       getAccountMeta(accounts.tokenMint),
-      getAccountMeta(accounts.signerTokenAccount),
       getAccountMeta(accounts.marketTokenAta),
+      getAccountMeta(accounts.ownerTokenAccount),
       getAccountMeta(accounts.tokenProgram),
       getAccountMeta(accounts.systemProgram)
     ],
-    data: getCloseStuckStakeAccountInstructionDataEncoder().encode(
-      args
-    ),
+    data: getCloseUnrevealedVouchAccountInstructionDataEncoder().encode({}),
     programAddress
   });
 }
-function getCloseStuckStakeAccountInstruction(input, config) {
+function getCloseUnrevealedVouchAccountInstruction(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
-    signer: { value: input.signer ?? null, isWritable: true },
-    market: { value: input.market ?? null, isWritable: false },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
+    owner: { value: input.owner ?? null, isWritable: true },
+    market: { value: input.market ?? null, isWritable: true },
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true },
     tokenMint: { value: input.tokenMint ?? null, isWritable: false },
-    signerTokenAccount: {
-      value: input.signerTokenAccount ?? null,
+    marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
+    ownerTokenAccount: {
+      value: input.ownerTokenAccount ?? null,
       isWritable: true
     },
-    marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
     tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
     systemProgram: { value: input.systemProgram ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
-  const args = { ...input };
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
   const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
   return Object.freeze({
     accounts: [
-      getAccountMeta(accounts.signer),
+      getAccountMeta(accounts.owner),
       getAccountMeta(accounts.market),
-      getAccountMeta(accounts.stakeAccount),
+      getAccountMeta(accounts.vouchAccount),
       getAccountMeta(accounts.tokenMint),
-      getAccountMeta(accounts.signerTokenAccount),
       getAccountMeta(accounts.marketTokenAta),
+      getAccountMeta(accounts.ownerTokenAccount),
       getAccountMeta(accounts.tokenProgram),
       getAccountMeta(accounts.systemProgram)
     ],
-    data: getCloseStuckStakeAccountInstructionDataEncoder().encode(
-      args
-    ),
+    data: getCloseUnrevealedVouchAccountInstructionDataEncoder().encode({}),
     programAddress
   });
 }
-function parseCloseStuckStakeAccountInstruction(instruction) {
+function parseCloseUnrevealedVouchAccountInstruction(instruction) {
   if (instruction.accounts.length < 8) {
     throw new Error("Not enough accounts");
   }
@@ -4509,22 +4514,22 @@ function parseCloseStuckStakeAccountInstruction(instruction) {
   return {
     programAddress: instruction.programAddress,
     accounts: {
-      signer: getNextAccount(),
+      owner: getNextAccount(),
       market: getNextAccount(),
-      stakeAccount: getNextAccount(),
+      vouchAccount: getNextAccount(),
       tokenMint: getNextAccount(),
-      signerTokenAccount: getNextAccount(),
       marketTokenAta: getNextAccount(),
+      ownerTokenAccount: getNextAccount(),
       tokenProgram: getNextAccount(),
       systemProgram: getNextAccount()
     },
-    data: getCloseStuckStakeAccountInstructionDataDecoder().decode(
+    data: getCloseUnrevealedVouchAccountInstructionDataDecoder().decode(
       instruction.data
     )
   };
 }
 
-// src/generated/instructions/closeUnrevealedStakeAccount.ts
+// src/generated/instructions/closeVouchAccount.ts
 import {
   combineCodec as combineCodec68,
   fixDecoderSize as fixDecoderSize16,
@@ -4537,47 +4542,45 @@ import {
   getStructEncoder as getStructEncoder62,
   transformEncoder as transformEncoder16
 } from "@solana/kit";
-var CLOSE_UNREVEALED_STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
-  171,
-  229,
-  236,
-  216,
-  122,
-  118,
-  188,
-  103
+var CLOSE_VOUCH_ACCOUNT_DISCRIMINATOR = new Uint8Array([
+  107,
+  196,
+  52,
+  68,
+  9,
+  214,
+  207,
+  109
 ]);
-function getCloseUnrevealedStakeAccountDiscriminatorBytes() {
+function getCloseVouchAccountDiscriminatorBytes() {
   return fixEncoderSize17(getBytesEncoder17(), 8).encode(
-    CLOSE_UNREVEALED_STAKE_ACCOUNT_DISCRIMINATOR
+    CLOSE_VOUCH_ACCOUNT_DISCRIMINATOR
   );
 }
-function getCloseUnrevealedStakeAccountInstructionDataEncoder() {
+function getCloseVouchAccountInstructionDataEncoder() {
   return transformEncoder16(
     getStructEncoder62([["discriminator", fixEncoderSize17(getBytesEncoder17(), 8)]]),
-    (value) => ({
-      ...value,
-      discriminator: CLOSE_UNREVEALED_STAKE_ACCOUNT_DISCRIMINATOR
-    })
+    (value) => ({ ...value, discriminator: CLOSE_VOUCH_ACCOUNT_DISCRIMINATOR })
   );
 }
-function getCloseUnrevealedStakeAccountInstructionDataDecoder() {
+function getCloseVouchAccountInstructionDataDecoder() {
   return getStructDecoder62([
     ["discriminator", fixDecoderSize16(getBytesDecoder16(), 8)]
   ]);
 }
-function getCloseUnrevealedStakeAccountInstructionDataCodec() {
+function getCloseVouchAccountInstructionDataCodec() {
   return combineCodec68(
-    getCloseUnrevealedStakeAccountInstructionDataEncoder(),
-    getCloseUnrevealedStakeAccountInstructionDataDecoder()
+    getCloseVouchAccountInstructionDataEncoder(),
+    getCloseVouchAccountInstructionDataDecoder()
   );
 }
-async function getCloseUnrevealedStakeAccountInstructionAsync(input, config) {
+async function getCloseVouchAccountInstructionAsync(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
     owner: { value: input.owner ?? null, isWritable: true },
     market: { value: input.market ?? null, isWritable: true },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true },
+    option: { value: input.option ?? null, isWritable: true },
     tokenMint: { value: input.tokenMint ?? null, isWritable: false },
     marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
     ownerTokenAccount: {
@@ -4606,23 +4609,25 @@ async function getCloseUnrevealedStakeAccountInstructionAsync(input, config) {
     accounts: [
       getAccountMeta(accounts.owner),
       getAccountMeta(accounts.market),
-      getAccountMeta(accounts.stakeAccount),
+      getAccountMeta(accounts.vouchAccount),
+      getAccountMeta(accounts.option),
       getAccountMeta(accounts.tokenMint),
       getAccountMeta(accounts.marketTokenAta),
       getAccountMeta(accounts.ownerTokenAccount),
       getAccountMeta(accounts.tokenProgram),
       getAccountMeta(accounts.systemProgram)
     ],
-    data: getCloseUnrevealedStakeAccountInstructionDataEncoder().encode({}),
+    data: getCloseVouchAccountInstructionDataEncoder().encode({}),
     programAddress
   });
 }
-function getCloseUnrevealedStakeAccountInstruction(input, config) {
+function getCloseVouchAccountInstruction(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
     owner: { value: input.owner ?? null, isWritable: true },
     market: { value: input.market ?? null, isWritable: true },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true },
+    option: { value: input.option ?? null, isWritable: true },
     tokenMint: { value: input.tokenMint ?? null, isWritable: false },
     marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
     ownerTokenAccount: {
@@ -4641,19 +4646,20 @@ function getCloseUnrevealedStakeAccountInstruction(input, config) {
     accounts: [
       getAccountMeta(accounts.owner),
       getAccountMeta(accounts.market),
-      getAccountMeta(accounts.stakeAccount),
+      getAccountMeta(accounts.vouchAccount),
+      getAccountMeta(accounts.option),
       getAccountMeta(accounts.tokenMint),
       getAccountMeta(accounts.marketTokenAta),
       getAccountMeta(accounts.ownerTokenAccount),
       getAccountMeta(accounts.tokenProgram),
       getAccountMeta(accounts.systemProgram)
     ],
-    data: getCloseUnrevealedStakeAccountInstructionDataEncoder().encode({}),
+    data: getCloseVouchAccountInstructionDataEncoder().encode({}),
     programAddress
   });
 }
-function parseCloseUnrevealedStakeAccountInstruction(instruction) {
-  if (instruction.accounts.length < 8) {
+function parseCloseVouchAccountInstruction(instruction) {
+  if (instruction.accounts.length < 9) {
     throw new Error("Not enough accounts");
   }
   let accountIndex = 0;
@@ -4667,16 +4673,15 @@ function parseCloseUnrevealedStakeAccountInstruction(instruction) {
     accounts: {
       owner: getNextAccount(),
       market: getNextAccount(),
-      stakeAccount: getNextAccount(),
+      vouchAccount: getNextAccount(),
+      option: getNextAccount(),
       tokenMint: getNextAccount(),
       marketTokenAta: getNextAccount(),
       ownerTokenAccount: getNextAccount(),
       tokenProgram: getNextAccount(),
       systemProgram: getNextAccount()
     },
-    data: getCloseUnrevealedStakeAccountInstructionDataDecoder().decode(
-      instruction.data
-    )
+    data: getCloseVouchAccountInstructionDataDecoder().decode(instruction.data)
   };
 }
 
@@ -4962,7 +4967,7 @@ function parseEndRevealPeriodInstruction(instruction) {
   };
 }
 
-// src/generated/instructions/finalizeRevealStake.ts
+// src/generated/instructions/finalizeRevealVouch.ts
 import {
   combineCodec as combineCodec71,
   fixDecoderSize as fixDecoderSize19,
@@ -4979,70 +4984,70 @@ import {
   getU64Encoder as getU64Encoder37,
   transformEncoder as transformEncoder19
 } from "@solana/kit";
-var FINALIZE_REVEAL_STAKE_DISCRIMINATOR = new Uint8Array([
-  92,
-  201,
-  94,
-  219,
-  117,
-  53,
-  255,
-  230
+var FINALIZE_REVEAL_VOUCH_DISCRIMINATOR = new Uint8Array([
+  1,
+  34,
+  40,
+  131,
+  236,
+  85,
+  1,
+  25
 ]);
-function getFinalizeRevealStakeDiscriminatorBytes() {
+function getFinalizeRevealVouchDiscriminatorBytes() {
   return fixEncoderSize20(getBytesEncoder20(), 8).encode(
-    FINALIZE_REVEAL_STAKE_DISCRIMINATOR
+    FINALIZE_REVEAL_VOUCH_DISCRIMINATOR
   );
 }
-function getFinalizeRevealStakeInstructionDataEncoder() {
+function getFinalizeRevealVouchInstructionDataEncoder() {
   return transformEncoder19(
     getStructEncoder65([
       ["discriminator", fixEncoderSize20(getBytesEncoder20(), 8)],
       ["optionId", getU64Encoder37()],
-      ["stakeAccountId", getU32Encoder19()]
+      ["vouchAccountId", getU32Encoder19()]
     ]),
     (value) => ({
       ...value,
-      discriminator: FINALIZE_REVEAL_STAKE_DISCRIMINATOR
+      discriminator: FINALIZE_REVEAL_VOUCH_DISCRIMINATOR
     })
   );
 }
-function getFinalizeRevealStakeInstructionDataDecoder() {
+function getFinalizeRevealVouchInstructionDataDecoder() {
   return getStructDecoder65([
     ["discriminator", fixDecoderSize19(getBytesDecoder19(), 8)],
     ["optionId", getU64Decoder37()],
-    ["stakeAccountId", getU32Decoder19()]
+    ["vouchAccountId", getU32Decoder19()]
   ]);
 }
-function getFinalizeRevealStakeInstructionDataCodec() {
+function getFinalizeRevealVouchInstructionDataCodec() {
   return combineCodec71(
-    getFinalizeRevealStakeInstructionDataEncoder(),
-    getFinalizeRevealStakeInstructionDataDecoder()
+    getFinalizeRevealVouchInstructionDataEncoder(),
+    getFinalizeRevealVouchInstructionDataDecoder()
   );
 }
-async function getFinalizeRevealStakeInstructionAsync(input, config) {
+async function getFinalizeRevealVouchInstructionAsync(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
     signer: { value: input.signer ?? null, isWritable: true },
     owner: { value: input.owner ?? null, isWritable: false },
     market: { value: input.market ?? null, isWritable: true },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true },
     option: { value: input.option ?? null, isWritable: true },
     systemProgram: { value: input.systemProgram ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  if (!accounts.stakeAccount.value) {
-    accounts.stakeAccount.value = await getProgramDerivedAddress11({
+  if (!accounts.vouchAccount.value) {
+    accounts.vouchAccount.value = await getProgramDerivedAddress11({
       programAddress,
       seeds: [
         getBytesEncoder20().encode(
           new Uint8Array([
-            115,
-            116,
-            97,
-            107,
-            101,
+            118,
+            111,
+            117,
+            99,
+            104,
             95,
             97,
             99,
@@ -5055,7 +5060,7 @@ async function getFinalizeRevealStakeInstructionAsync(input, config) {
         ),
         getAddressEncoder45().encode(expectAddress(accounts.owner.value)),
         getAddressEncoder45().encode(expectAddress(accounts.market.value)),
-        getU32Encoder19().encode(expectSome(args.stakeAccountId))
+        getU32Encoder19().encode(expectSome(args.vouchAccountId))
       ]
     });
   }
@@ -5080,23 +5085,23 @@ async function getFinalizeRevealStakeInstructionAsync(input, config) {
       getAccountMeta(accounts.signer),
       getAccountMeta(accounts.owner),
       getAccountMeta(accounts.market),
-      getAccountMeta(accounts.stakeAccount),
+      getAccountMeta(accounts.vouchAccount),
       getAccountMeta(accounts.option),
       getAccountMeta(accounts.systemProgram)
     ],
-    data: getFinalizeRevealStakeInstructionDataEncoder().encode(
+    data: getFinalizeRevealVouchInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function getFinalizeRevealStakeInstruction(input, config) {
+function getFinalizeRevealVouchInstruction(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
     signer: { value: input.signer ?? null, isWritable: true },
     owner: { value: input.owner ?? null, isWritable: false },
     market: { value: input.market ?? null, isWritable: true },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true },
     option: { value: input.option ?? null, isWritable: true },
     systemProgram: { value: input.systemProgram ?? null, isWritable: false }
   };
@@ -5111,17 +5116,17 @@ function getFinalizeRevealStakeInstruction(input, config) {
       getAccountMeta(accounts.signer),
       getAccountMeta(accounts.owner),
       getAccountMeta(accounts.market),
-      getAccountMeta(accounts.stakeAccount),
+      getAccountMeta(accounts.vouchAccount),
       getAccountMeta(accounts.option),
       getAccountMeta(accounts.systemProgram)
     ],
-    data: getFinalizeRevealStakeInstructionDataEncoder().encode(
+    data: getFinalizeRevealVouchInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function parseFinalizeRevealStakeInstruction(instruction) {
+function parseFinalizeRevealVouchInstruction(instruction) {
   if (instruction.accounts.length < 6) {
     throw new Error("Not enough accounts");
   }
@@ -5137,11 +5142,11 @@ function parseFinalizeRevealStakeInstruction(instruction) {
       signer: getNextAccount(),
       owner: getNextAccount(),
       market: getNextAccount(),
-      stakeAccount: getNextAccount(),
+      vouchAccount: getNextAccount(),
       option: getNextAccount(),
       systemProgram: getNextAccount()
     },
-    data: getFinalizeRevealStakeInstructionDataDecoder().decode(
+    data: getFinalizeRevealVouchInstructionDataDecoder().decode(
       instruction.data
     )
   };
@@ -5389,7 +5394,7 @@ function parseInitPlatformConfigInstruction(instruction) {
   };
 }
 
-// src/generated/instructions/initStakeAccount.ts
+// src/generated/instructions/initVouchAccount.ts
 import {
   combineCodec as combineCodec74,
   fixDecoderSize as fixDecoderSize22,
@@ -5404,64 +5409,64 @@ import {
   getU32Encoder as getU32Encoder20,
   transformEncoder as transformEncoder22
 } from "@solana/kit";
-var INIT_STAKE_ACCOUNT_DISCRIMINATOR = new Uint8Array([
-  132,
-  171,
-  255,
+var INIT_VOUCH_ACCOUNT_DISCRIMINATOR = new Uint8Array([
+  170,
+  190,
   149,
-  163,
-  37,
-  220,
-  45
+  246,
+  116,
+  216,
+  171,
+  230
 ]);
-function getInitStakeAccountDiscriminatorBytes() {
+function getInitVouchAccountDiscriminatorBytes() {
   return fixEncoderSize23(getBytesEncoder23(), 8).encode(
-    INIT_STAKE_ACCOUNT_DISCRIMINATOR
+    INIT_VOUCH_ACCOUNT_DISCRIMINATOR
   );
 }
-function getInitStakeAccountInstructionDataEncoder() {
+function getInitVouchAccountInstructionDataEncoder() {
   return transformEncoder22(
     getStructEncoder68([
       ["discriminator", fixEncoderSize23(getBytesEncoder23(), 8)],
-      ["stakeAccountId", getU32Encoder20()]
+      ["vouchAccountId", getU32Encoder20()]
     ]),
-    (value) => ({ ...value, discriminator: INIT_STAKE_ACCOUNT_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: INIT_VOUCH_ACCOUNT_DISCRIMINATOR })
   );
 }
-function getInitStakeAccountInstructionDataDecoder() {
+function getInitVouchAccountInstructionDataDecoder() {
   return getStructDecoder68([
     ["discriminator", fixDecoderSize22(getBytesDecoder22(), 8)],
-    ["stakeAccountId", getU32Decoder20()]
+    ["vouchAccountId", getU32Decoder20()]
   ]);
 }
-function getInitStakeAccountInstructionDataCodec() {
+function getInitVouchAccountInstructionDataCodec() {
   return combineCodec74(
-    getInitStakeAccountInstructionDataEncoder(),
-    getInitStakeAccountInstructionDataDecoder()
+    getInitVouchAccountInstructionDataEncoder(),
+    getInitVouchAccountInstructionDataDecoder()
   );
 }
-async function getInitStakeAccountInstructionAsync(input, config) {
+async function getInitVouchAccountInstructionAsync(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
     payer: { value: input.payer ?? null, isWritable: true },
     owner: { value: input.owner ?? null, isWritable: false },
     market: { value: input.market ?? null, isWritable: false },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true },
     systemProgram: { value: input.systemProgram ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  if (!accounts.stakeAccount.value) {
-    accounts.stakeAccount.value = await getProgramDerivedAddress13({
+  if (!accounts.vouchAccount.value) {
+    accounts.vouchAccount.value = await getProgramDerivedAddress13({
       programAddress,
       seeds: [
         getBytesEncoder23().encode(
           new Uint8Array([
-            115,
-            116,
-            97,
-            107,
-            101,
+            118,
+            111,
+            117,
+            99,
+            104,
             95,
             97,
             99,
@@ -5474,7 +5479,7 @@ async function getInitStakeAccountInstructionAsync(input, config) {
         ),
         getAddressEncoder47().encode(expectAddress(accounts.owner.value)),
         getAddressEncoder47().encode(expectAddress(accounts.market.value)),
-        getU32Encoder20().encode(expectSome(args.stakeAccountId))
+        getU32Encoder20().encode(expectSome(args.vouchAccountId))
       ]
     });
   }
@@ -5487,22 +5492,22 @@ async function getInitStakeAccountInstructionAsync(input, config) {
       getAccountMeta(accounts.payer),
       getAccountMeta(accounts.owner),
       getAccountMeta(accounts.market),
-      getAccountMeta(accounts.stakeAccount),
+      getAccountMeta(accounts.vouchAccount),
       getAccountMeta(accounts.systemProgram)
     ],
-    data: getInitStakeAccountInstructionDataEncoder().encode(
+    data: getInitVouchAccountInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function getInitStakeAccountInstruction(input, config) {
+function getInitVouchAccountInstruction(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
     payer: { value: input.payer ?? null, isWritable: true },
     owner: { value: input.owner ?? null, isWritable: false },
     market: { value: input.market ?? null, isWritable: false },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true },
     systemProgram: { value: input.systemProgram ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
@@ -5516,16 +5521,16 @@ function getInitStakeAccountInstruction(input, config) {
       getAccountMeta(accounts.payer),
       getAccountMeta(accounts.owner),
       getAccountMeta(accounts.market),
-      getAccountMeta(accounts.stakeAccount),
+      getAccountMeta(accounts.vouchAccount),
       getAccountMeta(accounts.systemProgram)
     ],
-    data: getInitStakeAccountInstructionDataEncoder().encode(
+    data: getInitVouchAccountInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function parseInitStakeAccountInstruction(instruction) {
+function parseInitVouchAccountInstruction(instruction) {
   if (instruction.accounts.length < 5) {
     throw new Error("Not enough accounts");
   }
@@ -5541,10 +5546,10 @@ function parseInitStakeAccountInstruction(instruction) {
       payer: getNextAccount(),
       owner: getNextAccount(),
       market: getNextAccount(),
-      stakeAccount: getNextAccount(),
+      vouchAccount: getNextAccount(),
       systemProgram: getNextAccount()
     },
-    data: getInitStakeAccountInstructionDataDecoder().decode(instruction.data)
+    data: getInitVouchAccountInstructionDataDecoder().decode(instruction.data)
   };
 }
 
@@ -5578,7 +5583,7 @@ function getOpenMarketInstructionDataEncoder() {
   return transformEncoder23(
     getStructEncoder69([
       ["discriminator", fixEncoderSize24(getBytesEncoder24(), 8)],
-      ["timeToStake", getU64Encoder38()]
+      ["timeToVouch", getU64Encoder38()]
     ]),
     (value) => ({ ...value, discriminator: OPEN_MARKET_DISCRIMINATOR })
   );
@@ -5586,7 +5591,7 @@ function getOpenMarketInstructionDataEncoder() {
 function getOpenMarketInstructionDataDecoder() {
   return getStructDecoder69([
     ["discriminator", fixDecoderSize23(getBytesDecoder23(), 8)],
-    ["timeToStake", getU64Decoder38()]
+    ["timeToVouch", getU64Decoder38()]
   ]);
 }
 function getOpenMarketInstructionDataCodec() {
@@ -5721,7 +5726,7 @@ function parseResolveMarketInstruction(instruction) {
   };
 }
 
-// src/generated/instructions/revealStake.ts
+// src/generated/instructions/revealVouch.ts
 import {
   combineCodec as combineCodec77,
   fixDecoderSize as fixDecoderSize25,
@@ -5738,51 +5743,51 @@ import {
   getU64Encoder as getU64Encoder39,
   transformEncoder as transformEncoder25
 } from "@solana/kit";
-var REVEAL_STAKE_DISCRIMINATOR = new Uint8Array([
-  107,
-  229,
-  210,
-  77,
-  126,
-  255,
-  243,
-  188
+var REVEAL_VOUCH_DISCRIMINATOR = new Uint8Array([
+  137,
+  238,
+  214,
+  30,
+  51,
+  142,
+  141,
+  105
 ]);
-function getRevealStakeDiscriminatorBytes() {
+function getRevealVouchDiscriminatorBytes() {
   return fixEncoderSize26(getBytesEncoder26(), 8).encode(
-    REVEAL_STAKE_DISCRIMINATOR
+    REVEAL_VOUCH_DISCRIMINATOR
   );
 }
-function getRevealStakeInstructionDataEncoder() {
+function getRevealVouchInstructionDataEncoder() {
   return transformEncoder25(
     getStructEncoder71([
       ["discriminator", fixEncoderSize26(getBytesEncoder26(), 8)],
       ["computationOffset", getU64Encoder39()],
-      ["stakeAccountId", getU32Encoder21()]
+      ["vouchAccountId", getU32Encoder21()]
     ]),
-    (value) => ({ ...value, discriminator: REVEAL_STAKE_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: REVEAL_VOUCH_DISCRIMINATOR })
   );
 }
-function getRevealStakeInstructionDataDecoder() {
+function getRevealVouchInstructionDataDecoder() {
   return getStructDecoder71([
     ["discriminator", fixDecoderSize25(getBytesDecoder25(), 8)],
     ["computationOffset", getU64Decoder39()],
-    ["stakeAccountId", getU32Decoder21()]
+    ["vouchAccountId", getU32Decoder21()]
   ]);
 }
-function getRevealStakeInstructionDataCodec() {
+function getRevealVouchInstructionDataCodec() {
   return combineCodec77(
-    getRevealStakeInstructionDataEncoder(),
-    getRevealStakeInstructionDataDecoder()
+    getRevealVouchInstructionDataEncoder(),
+    getRevealVouchInstructionDataDecoder()
   );
 }
-async function getRevealStakeInstructionAsync(input, config) {
+async function getRevealVouchInstructionAsync(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
     signer: { value: input.signer ?? null, isWritable: true },
     owner: { value: input.owner ?? null, isWritable: false },
     market: { value: input.market ?? null, isWritable: false },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true },
     signPdaAccount: { value: input.signPdaAccount ?? null, isWritable: true },
     mxeAccount: { value: input.mxeAccount ?? null, isWritable: false },
     mempoolAccount: { value: input.mempoolAccount ?? null, isWritable: true },
@@ -5800,17 +5805,17 @@ async function getRevealStakeInstructionAsync(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  if (!accounts.stakeAccount.value) {
-    accounts.stakeAccount.value = await getProgramDerivedAddress14({
+  if (!accounts.vouchAccount.value) {
+    accounts.vouchAccount.value = await getProgramDerivedAddress14({
       programAddress,
       seeds: [
         getBytesEncoder26().encode(
           new Uint8Array([
-            115,
-            116,
-            97,
-            107,
-            101,
+            118,
+            111,
+            117,
+            99,
+            104,
             95,
             97,
             99,
@@ -5823,7 +5828,7 @@ async function getRevealStakeInstructionAsync(input, config) {
         ),
         getAddressEncoder48().encode(expectAddress(accounts.owner.value)),
         getAddressEncoder48().encode(expectAddress(accounts.market.value)),
-        getU32Encoder21().encode(expectSome(args.stakeAccountId))
+        getU32Encoder21().encode(expectSome(args.vouchAccountId))
       ]
     });
   }
@@ -5875,7 +5880,7 @@ async function getRevealStakeInstructionAsync(input, config) {
       getAccountMeta(accounts.signer),
       getAccountMeta(accounts.owner),
       getAccountMeta(accounts.market),
-      getAccountMeta(accounts.stakeAccount),
+      getAccountMeta(accounts.vouchAccount),
       getAccountMeta(accounts.signPdaAccount),
       getAccountMeta(accounts.mxeAccount),
       getAccountMeta(accounts.mempoolAccount),
@@ -5888,19 +5893,19 @@ async function getRevealStakeInstructionAsync(input, config) {
       getAccountMeta(accounts.systemProgram),
       getAccountMeta(accounts.arciumProgram)
     ],
-    data: getRevealStakeInstructionDataEncoder().encode(
+    data: getRevealVouchInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function getRevealStakeInstruction(input, config) {
+function getRevealVouchInstruction(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
     signer: { value: input.signer ?? null, isWritable: true },
     owner: { value: input.owner ?? null, isWritable: false },
     market: { value: input.market ?? null, isWritable: false },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true },
     signPdaAccount: { value: input.signPdaAccount ?? null, isWritable: true },
     mxeAccount: { value: input.mxeAccount ?? null, isWritable: false },
     mempoolAccount: { value: input.mempoolAccount ?? null, isWritable: true },
@@ -5936,7 +5941,7 @@ function getRevealStakeInstruction(input, config) {
       getAccountMeta(accounts.signer),
       getAccountMeta(accounts.owner),
       getAccountMeta(accounts.market),
-      getAccountMeta(accounts.stakeAccount),
+      getAccountMeta(accounts.vouchAccount),
       getAccountMeta(accounts.signPdaAccount),
       getAccountMeta(accounts.mxeAccount),
       getAccountMeta(accounts.mempoolAccount),
@@ -5949,13 +5954,13 @@ function getRevealStakeInstruction(input, config) {
       getAccountMeta(accounts.systemProgram),
       getAccountMeta(accounts.arciumProgram)
     ],
-    data: getRevealStakeInstructionDataEncoder().encode(
+    data: getRevealVouchInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function parseRevealStakeInstruction(instruction) {
+function parseRevealVouchInstruction(instruction) {
   if (instruction.accounts.length < 15) {
     throw new Error("Not enough accounts");
   }
@@ -5971,7 +5976,7 @@ function parseRevealStakeInstruction(instruction) {
       signer: getNextAccount(),
       owner: getNextAccount(),
       market: getNextAccount(),
-      stakeAccount: getNextAccount(),
+      vouchAccount: getNextAccount(),
       signPdaAccount: getNextAccount(),
       mxeAccount: getNextAccount(),
       mempoolAccount: getNextAccount(),
@@ -5984,11 +5989,11 @@ function parseRevealStakeInstruction(instruction) {
       systemProgram: getNextAccount(),
       arciumProgram: getNextAccount()
     },
-    data: getRevealStakeInstructionDataDecoder().decode(instruction.data)
+    data: getRevealVouchInstructionDataDecoder().decode(instruction.data)
   };
 }
 
-// src/generated/instructions/revealStakeCallback.ts
+// src/generated/instructions/revealVouchCallback.ts
 import {
   combineCodec as combineCodec78,
   fixDecoderSize as fixDecoderSize26,
@@ -6009,22 +6014,22 @@ import {
   getUnitEncoder,
   transformEncoder as transformEncoder26
 } from "@solana/kit";
-var REVEAL_STAKE_CALLBACK_DISCRIMINATOR = new Uint8Array([
-  79,
-  19,
-  120,
-  162,
-  232,
-  39,
-  206,
-  116
+var REVEAL_VOUCH_CALLBACK_DISCRIMINATOR = new Uint8Array([
+  251,
+  246,
+  6,
+  118,
+  139,
+  46,
+  136,
+  190
 ]);
-function getRevealStakeCallbackDiscriminatorBytes() {
+function getRevealVouchCallbackDiscriminatorBytes() {
   return fixEncoderSize27(getBytesEncoder27(), 8).encode(
-    REVEAL_STAKE_CALLBACK_DISCRIMINATOR
+    REVEAL_VOUCH_CALLBACK_DISCRIMINATOR
   );
 }
-function getRevealStakeCallbackInstructionDataEncoder() {
+function getRevealVouchCallbackInstructionDataEncoder() {
   return transformEncoder26(
     getStructEncoder72([
       ["discriminator", fixEncoderSize27(getBytesEncoder27(), 8)],
@@ -6037,7 +6042,7 @@ function getRevealStakeCallbackInstructionDataEncoder() {
               [
                 "fields",
                 getTupleEncoder6([
-                  getRevealStakeOutputEncoder(),
+                  getRevealVouchOutputEncoder(),
                   getArrayEncoder16(getU8Encoder23(), { size: 64 })
                 ])
               ]
@@ -6047,7 +6052,7 @@ function getRevealStakeCallbackInstructionDataEncoder() {
           [
             "MarkerForIdlBuildDoNotUseThis",
             getStructEncoder72([
-              ["fields", getTupleEncoder6([getRevealStakeOutputEncoder()])]
+              ["fields", getTupleEncoder6([getRevealVouchOutputEncoder()])]
             ])
           ]
         ])
@@ -6055,11 +6060,11 @@ function getRevealStakeCallbackInstructionDataEncoder() {
     ]),
     (value) => ({
       ...value,
-      discriminator: REVEAL_STAKE_CALLBACK_DISCRIMINATOR
+      discriminator: REVEAL_VOUCH_CALLBACK_DISCRIMINATOR
     })
   );
 }
-function getRevealStakeCallbackInstructionDataDecoder() {
+function getRevealVouchCallbackInstructionDataDecoder() {
   return getStructDecoder72([
     ["discriminator", fixDecoderSize26(getBytesDecoder26(), 8)],
     [
@@ -6071,7 +6076,7 @@ function getRevealStakeCallbackInstructionDataDecoder() {
             [
               "fields",
               getTupleDecoder6([
-                getRevealStakeOutputDecoder(),
+                getRevealVouchOutputDecoder(),
                 getArrayDecoder16(getU8Decoder23(), { size: 64 })
               ])
             ]
@@ -6081,20 +6086,20 @@ function getRevealStakeCallbackInstructionDataDecoder() {
         [
           "MarkerForIdlBuildDoNotUseThis",
           getStructDecoder72([
-            ["fields", getTupleDecoder6([getRevealStakeOutputDecoder()])]
+            ["fields", getTupleDecoder6([getRevealVouchOutputDecoder()])]
           ])
         ]
       ])
     ]
   ]);
 }
-function getRevealStakeCallbackInstructionDataCodec() {
+function getRevealVouchCallbackInstructionDataCodec() {
   return combineCodec78(
-    getRevealStakeCallbackInstructionDataEncoder(),
-    getRevealStakeCallbackInstructionDataDecoder()
+    getRevealVouchCallbackInstructionDataEncoder(),
+    getRevealVouchCallbackInstructionDataDecoder()
   );
 }
-function getRevealStakeCallbackInstruction(input, config) {
+function getRevealVouchCallbackInstruction(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
     arciumProgram: { value: input.arciumProgram ?? null, isWritable: false },
@@ -6109,7 +6114,7 @@ function getRevealStakeCallbackInstruction(input, config) {
       value: input.instructionsSysvar ?? null,
       isWritable: false
     },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true }
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true }
   };
   const accounts = originalAccounts;
   const args = { ...input };
@@ -6128,15 +6133,15 @@ function getRevealStakeCallbackInstruction(input, config) {
       getAccountMeta(accounts.computationAccount),
       getAccountMeta(accounts.clusterAccount),
       getAccountMeta(accounts.instructionsSysvar),
-      getAccountMeta(accounts.stakeAccount)
+      getAccountMeta(accounts.vouchAccount)
     ],
-    data: getRevealStakeCallbackInstructionDataEncoder().encode(
+    data: getRevealVouchCallbackInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function parseRevealStakeCallbackInstruction(instruction) {
+function parseRevealVouchCallbackInstruction(instruction) {
   if (instruction.accounts.length < 7) {
     throw new Error("Not enough accounts");
   }
@@ -6155,15 +6160,15 @@ function parseRevealStakeCallbackInstruction(instruction) {
       computationAccount: getNextAccount(),
       clusterAccount: getNextAccount(),
       instructionsSysvar: getNextAccount(),
-      stakeAccount: getNextAccount()
+      vouchAccount: getNextAccount()
     },
-    data: getRevealStakeCallbackInstructionDataDecoder().decode(
+    data: getRevealVouchCallbackInstructionDataDecoder().decode(
       instruction.data
     )
   };
 }
 
-// src/generated/instructions/revealStakeCompDef.ts
+// src/generated/instructions/revealVouchCompDef.ts
 import {
   combineCodec as combineCodec79,
   fixDecoderSize as fixDecoderSize27,
@@ -6174,42 +6179,42 @@ import {
   getStructEncoder as getStructEncoder73,
   transformEncoder as transformEncoder27
 } from "@solana/kit";
-var REVEAL_STAKE_COMP_DEF_DISCRIMINATOR = new Uint8Array([
-  197,
-  20,
-  216,
-  132,
-  43,
-  99,
-  64,
-  0
+var REVEAL_VOUCH_COMP_DEF_DISCRIMINATOR = new Uint8Array([
+  176,
+  228,
+  5,
+  47,
+  19,
+  6,
+  243,
+  236
 ]);
-function getRevealStakeCompDefDiscriminatorBytes() {
+function getRevealVouchCompDefDiscriminatorBytes() {
   return fixEncoderSize28(getBytesEncoder28(), 8).encode(
-    REVEAL_STAKE_COMP_DEF_DISCRIMINATOR
+    REVEAL_VOUCH_COMP_DEF_DISCRIMINATOR
   );
 }
-function getRevealStakeCompDefInstructionDataEncoder() {
+function getRevealVouchCompDefInstructionDataEncoder() {
   return transformEncoder27(
     getStructEncoder73([["discriminator", fixEncoderSize28(getBytesEncoder28(), 8)]]),
     (value) => ({
       ...value,
-      discriminator: REVEAL_STAKE_COMP_DEF_DISCRIMINATOR
+      discriminator: REVEAL_VOUCH_COMP_DEF_DISCRIMINATOR
     })
   );
 }
-function getRevealStakeCompDefInstructionDataDecoder() {
+function getRevealVouchCompDefInstructionDataDecoder() {
   return getStructDecoder73([
     ["discriminator", fixDecoderSize27(getBytesDecoder27(), 8)]
   ]);
 }
-function getRevealStakeCompDefInstructionDataCodec() {
+function getRevealVouchCompDefInstructionDataCodec() {
   return combineCodec79(
-    getRevealStakeCompDefInstructionDataEncoder(),
-    getRevealStakeCompDefInstructionDataDecoder()
+    getRevealVouchCompDefInstructionDataEncoder(),
+    getRevealVouchCompDefInstructionDataDecoder()
   );
 }
-function getRevealStakeCompDefInstruction(input, config) {
+function getRevealVouchCompDefInstruction(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
     payer: { value: input.payer ?? null, isWritable: true },
@@ -6244,11 +6249,11 @@ function getRevealStakeCompDefInstruction(input, config) {
       getAccountMeta(accounts.arciumProgram),
       getAccountMeta(accounts.systemProgram)
     ],
-    data: getRevealStakeCompDefInstructionDataEncoder().encode({}),
+    data: getRevealVouchCompDefInstructionDataEncoder().encode({}),
     programAddress
   });
 }
-function parseRevealStakeCompDefInstruction(instruction) {
+function parseRevealVouchCompDefInstruction(instruction) {
   if (instruction.accounts.length < 7) {
     throw new Error("Not enough accounts");
   }
@@ -6269,7 +6274,7 @@ function parseRevealStakeCompDefInstruction(instruction) {
       arciumProgram: getNextAccount(),
       systemProgram: getNextAccount()
     },
-    data: getRevealStakeCompDefInstructionDataDecoder().decode(
+    data: getRevealVouchCompDefInstructionDataDecoder().decode(
       instruction.data
     )
   };
@@ -6595,60 +6600,155 @@ function parseSetWinningOptionInstruction(instruction) {
   };
 }
 
-// src/generated/instructions/stake.ts
+// src/generated/instructions/updatePlatformConfig.ts
 import {
   combineCodec as combineCodec83,
   fixDecoderSize as fixDecoderSize31,
   fixEncoderSize as fixEncoderSize32,
-  getAddressEncoder as getAddressEncoder50,
   getBytesDecoder as getBytesDecoder31,
   getBytesEncoder as getBytesEncoder32,
-  getProgramDerivedAddress as getProgramDerivedAddress16,
   getStructDecoder as getStructDecoder77,
   getStructEncoder as getStructEncoder77,
   transformEncoder as transformEncoder31
 } from "@solana/kit";
-var STAKE_DISCRIMINATOR = new Uint8Array([
-  206,
-  176,
-  202,
-  18,
-  200,
-  209,
-  179,
-  108
+var UPDATE_PLATFORM_CONFIG_DISCRIMINATOR = new Uint8Array([
+  195,
+  60,
+  76,
+  129,
+  146,
+  45,
+  67,
+  143
 ]);
-function getStakeDiscriminatorBytes() {
-  return fixEncoderSize32(getBytesEncoder32(), 8).encode(STAKE_DISCRIMINATOR);
+function getUpdatePlatformConfigDiscriminatorBytes() {
+  return fixEncoderSize32(getBytesEncoder32(), 8).encode(
+    UPDATE_PLATFORM_CONFIG_DISCRIMINATOR
+  );
 }
-function getStakeInstructionDataEncoder() {
+function getUpdatePlatformConfigInstructionDataEncoder() {
   return transformEncoder31(
     getStructEncoder77([
       ["discriminator", fixEncoderSize32(getBytesEncoder32(), 8)],
-      ["params", getStakeParametersEncoder()]
+      ["params", getUpdatePlatformParametersEncoder()]
     ]),
-    (value) => ({ ...value, discriminator: STAKE_DISCRIMINATOR })
+    (value) => ({
+      ...value,
+      discriminator: UPDATE_PLATFORM_CONFIG_DISCRIMINATOR
+    })
   );
 }
-function getStakeInstructionDataDecoder() {
+function getUpdatePlatformConfigInstructionDataDecoder() {
   return getStructDecoder77([
     ["discriminator", fixDecoderSize31(getBytesDecoder31(), 8)],
-    ["params", getStakeParametersDecoder()]
+    ["params", getUpdatePlatformParametersDecoder()]
   ]);
 }
-function getStakeInstructionDataCodec() {
+function getUpdatePlatformConfigInstructionDataCodec() {
   return combineCodec83(
-    getStakeInstructionDataEncoder(),
-    getStakeInstructionDataDecoder()
+    getUpdatePlatformConfigInstructionDataEncoder(),
+    getUpdatePlatformConfigInstructionDataDecoder()
+  );
+}
+function getUpdatePlatformConfigInstruction(input, config) {
+  const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    updateAuthority: {
+      value: input.updateAuthority ?? null,
+      isWritable: false
+    },
+    platformConfig: { value: input.platformConfig ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.updateAuthority),
+      getAccountMeta(accounts.platformConfig)
+    ],
+    data: getUpdatePlatformConfigInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseUpdatePlatformConfigInstruction(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: {
+      updateAuthority: getNextAccount(),
+      platformConfig: getNextAccount()
+    },
+    data: getUpdatePlatformConfigInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+
+// src/generated/instructions/vouch.ts
+import {
+  combineCodec as combineCodec84,
+  fixDecoderSize as fixDecoderSize32,
+  fixEncoderSize as fixEncoderSize33,
+  getAddressEncoder as getAddressEncoder50,
+  getBytesDecoder as getBytesDecoder32,
+  getBytesEncoder as getBytesEncoder33,
+  getProgramDerivedAddress as getProgramDerivedAddress16,
+  getStructDecoder as getStructDecoder78,
+  getStructEncoder as getStructEncoder78,
+  transformEncoder as transformEncoder32
+} from "@solana/kit";
+var VOUCH_DISCRIMINATOR = new Uint8Array([
+  87,
+  240,
+  8,
+  21,
+  219,
+  179,
+  242,
+  177
+]);
+function getVouchDiscriminatorBytes() {
+  return fixEncoderSize33(getBytesEncoder33(), 8).encode(VOUCH_DISCRIMINATOR);
+}
+function getVouchInstructionDataEncoder() {
+  return transformEncoder32(
+    getStructEncoder78([
+      ["discriminator", fixEncoderSize33(getBytesEncoder33(), 8)],
+      ["params", getVouchParametersEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: VOUCH_DISCRIMINATOR })
+  );
+}
+function getVouchInstructionDataDecoder() {
+  return getStructDecoder78([
+    ["discriminator", fixDecoderSize32(getBytesDecoder32(), 8)],
+    ["params", getVouchParametersDecoder()]
+  ]);
+}
+function getVouchInstructionDataCodec() {
+  return combineCodec84(
+    getVouchInstructionDataEncoder(),
+    getVouchInstructionDataDecoder()
   );
 }
-async function getStakeInstructionAsync(input, config) {
+async function getVouchInstructionAsync(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
     signer: { value: input.signer ?? null, isWritable: false },
     payer: { value: input.payer ?? null, isWritable: true },
     market: { value: input.market ?? null, isWritable: true },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true },
     tokenMint: { value: input.tokenMint ?? null, isWritable: false },
     signerTokenAccount: {
       value: input.signerTokenAccount ?? null,
@@ -6687,7 +6787,7 @@ async function getStakeInstructionAsync(input, config) {
     accounts.signPdaAccount.value = await getProgramDerivedAddress16({
       programAddress,
       seeds: [
-        getBytesEncoder32().encode(
+        getBytesEncoder33().encode(
           new Uint8Array([
             65,
             114,
@@ -6731,7 +6831,7 @@ async function getStakeInstructionAsync(input, config) {
       getAccountMeta(accounts.signer),
       getAccountMeta(accounts.payer),
       getAccountMeta(accounts.market),
-      getAccountMeta(accounts.stakeAccount),
+      getAccountMeta(accounts.vouchAccount),
       getAccountMeta(accounts.tokenMint),
       getAccountMeta(accounts.signerTokenAccount),
       getAccountMeta(accounts.marketTokenAta),
@@ -6748,19 +6848,19 @@ async function getStakeInstructionAsync(input, config) {
       getAccountMeta(accounts.systemProgram),
       getAccountMeta(accounts.arciumProgram)
     ],
-    data: getStakeInstructionDataEncoder().encode(
+    data: getVouchInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function getStakeInstruction(input, config) {
+function getVouchInstruction(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
     signer: { value: input.signer ?? null, isWritable: false },
     payer: { value: input.payer ?? null, isWritable: true },
     market: { value: input.market ?? null, isWritable: true },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true },
     tokenMint: { value: input.tokenMint ?? null, isWritable: false },
     signerTokenAccount: {
       value: input.signerTokenAccount ?? null,
@@ -6803,7 +6903,7 @@ function getStakeInstruction(input, config) {
       getAccountMeta(accounts.signer),
       getAccountMeta(accounts.payer),
       getAccountMeta(accounts.market),
-      getAccountMeta(accounts.stakeAccount),
+      getAccountMeta(accounts.vouchAccount),
       getAccountMeta(accounts.tokenMint),
       getAccountMeta(accounts.signerTokenAccount),
       getAccountMeta(accounts.marketTokenAta),
@@ -6820,13 +6920,13 @@ function getStakeInstruction(input, config) {
       getAccountMeta(accounts.systemProgram),
       getAccountMeta(accounts.arciumProgram)
     ],
-    data: getStakeInstructionDataEncoder().encode(
+    data: getVouchInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function parseStakeInstruction(instruction) {
+function parseVouchInstruction(instruction) {
   if (instruction.accounts.length < 19) {
     throw new Error("Not enough accounts");
   }
@@ -6842,7 +6942,7 @@ function parseStakeInstruction(instruction) {
       signer: getNextAccount(),
       payer: getNextAccount(),
       market: getNextAccount(),
-      stakeAccount: getNextAccount(),
+      vouchAccount: getNextAccount(),
       tokenMint: getNextAccount(),
       signerTokenAccount: getNextAccount(),
       marketTokenAta: getNextAccount(),
@@ -6859,60 +6959,60 @@ function parseStakeInstruction(instruction) {
       systemProgram: getNextAccount(),
       arciumProgram: getNextAccount()
     },
-    data: getStakeInstructionDataDecoder().decode(instruction.data)
+    data: getVouchInstructionDataDecoder().decode(instruction.data)
   };
 }
 
-// src/generated/instructions/stakeCallback.ts
+// src/generated/instructions/vouchCallback.ts
 import {
-  combineCodec as combineCodec84,
-  fixDecoderSize as fixDecoderSize32,
-  fixEncoderSize as fixEncoderSize33,
+  combineCodec as combineCodec85,
+  fixDecoderSize as fixDecoderSize33,
+  fixEncoderSize as fixEncoderSize34,
   getArrayDecoder as getArrayDecoder17,
   getArrayEncoder as getArrayEncoder17,
-  getBytesDecoder as getBytesDecoder32,
-  getBytesEncoder as getBytesEncoder33,
+  getBytesDecoder as getBytesDecoder33,
+  getBytesEncoder as getBytesEncoder34,
   getDiscriminatedUnionDecoder as getDiscriminatedUnionDecoder5,
   getDiscriminatedUnionEncoder as getDiscriminatedUnionEncoder5,
-  getStructDecoder as getStructDecoder78,
-  getStructEncoder as getStructEncoder78,
+  getStructDecoder as getStructDecoder79,
+  getStructEncoder as getStructEncoder79,
   getTupleDecoder as getTupleDecoder7,
   getTupleEncoder as getTupleEncoder7,
   getU8Decoder as getU8Decoder24,
   getU8Encoder as getU8Encoder24,
   getUnitDecoder as getUnitDecoder2,
   getUnitEncoder as getUnitEncoder2,
-  transformEncoder as transformEncoder32
+  transformEncoder as transformEncoder33
 } from "@solana/kit";
-var STAKE_CALLBACK_DISCRIMINATOR = new Uint8Array([
-  40,
-  220,
-  36,
-  47,
-  6,
-  116,
-  132,
-  89
+var VOUCH_CALLBACK_DISCRIMINATOR = new Uint8Array([
+  10,
+  0,
+  52,
+  15,
+  179,
+  148,
+  194,
+  135
 ]);
-function getStakeCallbackDiscriminatorBytes() {
-  return fixEncoderSize33(getBytesEncoder33(), 8).encode(
-    STAKE_CALLBACK_DISCRIMINATOR
+function getVouchCallbackDiscriminatorBytes() {
+  return fixEncoderSize34(getBytesEncoder34(), 8).encode(
+    VOUCH_CALLBACK_DISCRIMINATOR
   );
 }
-function getStakeCallbackInstructionDataEncoder() {
-  return transformEncoder32(
-    getStructEncoder78([
-      ["discriminator", fixEncoderSize33(getBytesEncoder33(), 8)],
+function getVouchCallbackInstructionDataEncoder() {
+  return transformEncoder33(
+    getStructEncoder79([
+      ["discriminator", fixEncoderSize34(getBytesEncoder34(), 8)],
       [
         "output",
         getDiscriminatedUnionEncoder5([
           [
             "Success",
-            getStructEncoder78([
+            getStructEncoder79([
               [
                 "fields",
                 getTupleEncoder7([
-                  getStakeOutputEncoder(),
+                  getVouchOutputEncoder(),
                   getArrayEncoder17(getU8Encoder24(), { size: 64 })
                 ])
               ]
@@ -6921,29 +7021,29 @@ function getStakeCallbackInstructionDataEncoder() {
           ["Failure", getUnitEncoder2()],
           [
             "MarkerForIdlBuildDoNotUseThis",
-            getStructEncoder78([
-              ["fields", getTupleEncoder7([getStakeOutputEncoder()])]
+            getStructEncoder79([
+              ["fields", getTupleEncoder7([getVouchOutputEncoder()])]
             ])
           ]
         ])
       ]
     ]),
-    (value) => ({ ...value, discriminator: STAKE_CALLBACK_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: VOUCH_CALLBACK_DISCRIMINATOR })
   );
 }
-function getStakeCallbackInstructionDataDecoder() {
-  return getStructDecoder78([
-    ["discriminator", fixDecoderSize32(getBytesDecoder32(), 8)],
+function getVouchCallbackInstructionDataDecoder() {
+  return getStructDecoder79([
+    ["discriminator", fixDecoderSize33(getBytesDecoder33(), 8)],
     [
       "output",
       getDiscriminatedUnionDecoder5([
         [
           "Success",
-          getStructDecoder78([
+          getStructDecoder79([
             [
               "fields",
               getTupleDecoder7([
-                getStakeOutputDecoder(),
+                getVouchOutputDecoder(),
                 getArrayDecoder17(getU8Decoder24(), { size: 64 })
               ])
             ]
@@ -6952,21 +7052,21 @@ function getStakeCallbackInstructionDataDecoder() {
         ["Failure", getUnitDecoder2()],
         [
           "MarkerForIdlBuildDoNotUseThis",
-          getStructDecoder78([
-            ["fields", getTupleDecoder7([getStakeOutputDecoder()])]
+          getStructDecoder79([
+            ["fields", getTupleDecoder7([getVouchOutputDecoder()])]
           ])
         ]
       ])
     ]
   ]);
 }
-function getStakeCallbackInstructionDataCodec() {
-  return combineCodec84(
-    getStakeCallbackInstructionDataEncoder(),
-    getStakeCallbackInstructionDataDecoder()
+function getVouchCallbackInstructionDataCodec() {
+  return combineCodec85(
+    getVouchCallbackInstructionDataEncoder(),
+    getVouchCallbackInstructionDataDecoder()
   );
 }
-function getStakeCallbackInstruction(input, config) {
+function getVouchCallbackInstruction(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
     arciumProgram: { value: input.arciumProgram ?? null, isWritable: false },
@@ -6981,7 +7081,7 @@ function getStakeCallbackInstruction(input, config) {
       value: input.instructionsSysvar ?? null,
       isWritable: false
     },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true },
     market: { value: input.market ?? null, isWritable: true }
   };
   const accounts = originalAccounts;
@@ -7001,16 +7101,16 @@ function getStakeCallbackInstruction(input, config) {
       getAccountMeta(accounts.computationAccount),
       getAccountMeta(accounts.clusterAccount),
       getAccountMeta(accounts.instructionsSysvar),
-      getAccountMeta(accounts.stakeAccount),
+      getAccountMeta(accounts.vouchAccount),
       getAccountMeta(accounts.market)
     ],
-    data: getStakeCallbackInstructionDataEncoder().encode(
+    data: getVouchCallbackInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function parseStakeCallbackInstruction(instruction) {
+function parseVouchCallbackInstruction(instruction) {
   if (instruction.accounts.length < 8) {
     throw new Error("Not enough accounts");
   }
@@ -7029,388 +7129,97 @@ function parseStakeCallbackInstruction(instruction) {
       computationAccount: getNextAccount(),
       clusterAccount: getNextAccount(),
       instructionsSysvar: getNextAccount(),
-      stakeAccount: getNextAccount(),
+      vouchAccount: getNextAccount(),
       market: getNextAccount()
     },
-    data: getStakeCallbackInstructionDataDecoder().decode(instruction.data)
+    data: getVouchCallbackInstructionDataDecoder().decode(instruction.data)
   };
 }
 
-// src/generated/instructions/stakeCompDef.ts
-import {
-  combineCodec as combineCodec85,
-  fixDecoderSize as fixDecoderSize33,
-  fixEncoderSize as fixEncoderSize34,
-  getBytesDecoder as getBytesDecoder33,
-  getBytesEncoder as getBytesEncoder34,
-  getStructDecoder as getStructDecoder79,
-  getStructEncoder as getStructEncoder79,
-  transformEncoder as transformEncoder33
-} from "@solana/kit";
-var STAKE_COMP_DEF_DISCRIMINATOR = new Uint8Array([
-  156,
-  5,
-  60,
-  126,
-  142,
-  149,
-  1,
-  130
-]);
-function getStakeCompDefDiscriminatorBytes() {
-  return fixEncoderSize34(getBytesEncoder34(), 8).encode(
-    STAKE_COMP_DEF_DISCRIMINATOR
-  );
-}
-function getStakeCompDefInstructionDataEncoder() {
-  return transformEncoder33(
-    getStructEncoder79([["discriminator", fixEncoderSize34(getBytesEncoder34(), 8)]]),
-    (value) => ({ ...value, discriminator: STAKE_COMP_DEF_DISCRIMINATOR })
-  );
-}
-function getStakeCompDefInstructionDataDecoder() {
-  return getStructDecoder79([
-    ["discriminator", fixDecoderSize33(getBytesDecoder33(), 8)]
-  ]);
-}
-function getStakeCompDefInstructionDataCodec() {
-  return combineCodec85(
-    getStakeCompDefInstructionDataEncoder(),
-    getStakeCompDefInstructionDataDecoder()
-  );
-}
-function getStakeCompDefInstruction(input, config) {
-  const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    payer: { value: input.payer ?? null, isWritable: true },
-    mxeAccount: { value: input.mxeAccount ?? null, isWritable: true },
-    compDefAccount: { value: input.compDefAccount ?? null, isWritable: true },
-    addressLookupTable: {
-      value: input.addressLookupTable ?? null,
-      isWritable: true
-    },
-    lutProgram: { value: input.lutProgram ?? null, isWritable: false },
-    arciumProgram: { value: input.arciumProgram ?? null, isWritable: false },
-    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
-  };
-  const accounts = originalAccounts;
-  if (!accounts.lutProgram.value) {
-    accounts.lutProgram.value = "AddressLookupTab1e1111111111111111111111111";
-  }
-  if (!accounts.arciumProgram.value) {
-    accounts.arciumProgram.value = "Arcj82pX7HxYKLR92qvgZUAd7vGS1k4hQvAFcPATFdEQ";
-  }
-  if (!accounts.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.payer),
-      getAccountMeta(accounts.mxeAccount),
-      getAccountMeta(accounts.compDefAccount),
-      getAccountMeta(accounts.addressLookupTable),
-      getAccountMeta(accounts.lutProgram),
-      getAccountMeta(accounts.arciumProgram),
-      getAccountMeta(accounts.systemProgram)
-    ],
-    data: getStakeCompDefInstructionDataEncoder().encode({}),
-    programAddress
-  });
-}
-function parseStakeCompDefInstruction(instruction) {
-  if (instruction.accounts.length < 7) {
-    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: {
-      payer: getNextAccount(),
-      mxeAccount: getNextAccount(),
-      compDefAccount: getNextAccount(),
-      addressLookupTable: getNextAccount(),
-      lutProgram: getNextAccount(),
-      arciumProgram: getNextAccount(),
-      systemProgram: getNextAccount()
-    },
-    data: getStakeCompDefInstructionDataDecoder().decode(instruction.data)
-  };
-}
-
-// src/generated/instructions/unstake.ts
+// src/generated/instructions/vouchCompDef.ts
 import {
   combineCodec as combineCodec86,
   fixDecoderSize as fixDecoderSize34,
   fixEncoderSize as fixEncoderSize35,
-  getAddressEncoder as getAddressEncoder51,
   getBytesDecoder as getBytesDecoder34,
   getBytesEncoder as getBytesEncoder35,
-  getProgramDerivedAddress as getProgramDerivedAddress17,
   getStructDecoder as getStructDecoder80,
   getStructEncoder as getStructEncoder80,
-  getU32Decoder as getU32Decoder22,
-  getU32Encoder as getU32Encoder22,
   transformEncoder as transformEncoder34
 } from "@solana/kit";
-var UNSTAKE_DISCRIMINATOR = new Uint8Array([
-  90,
+var VOUCH_COMP_DEF_DISCRIMINATOR = new Uint8Array([
+  138,
+  27,
   95,
-  107,
-  42,
-  205,
-  124,
-  50,
-  225
-]);
-function getUnstakeDiscriminatorBytes() {
-  return fixEncoderSize35(getBytesEncoder35(), 8).encode(UNSTAKE_DISCRIMINATOR);
-}
-function getUnstakeInstructionDataEncoder() {
-  return transformEncoder34(
-    getStructEncoder80([
-      ["discriminator", fixEncoderSize35(getBytesEncoder35(), 8)],
-      ["stakeAccountId", getU32Encoder22()]
-    ]),
-    (value) => ({ ...value, discriminator: UNSTAKE_DISCRIMINATOR })
-  );
-}
-function getUnstakeInstructionDataDecoder() {
-  return getStructDecoder80([
-    ["discriminator", fixDecoderSize34(getBytesDecoder34(), 8)],
-    ["stakeAccountId", getU32Decoder22()]
-  ]);
-}
-function getUnstakeInstructionDataCodec() {
-  return combineCodec86(
-    getUnstakeInstructionDataEncoder(),
-    getUnstakeInstructionDataDecoder()
-  );
-}
-async function getUnstakeInstructionAsync(input, config) {
-  const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    signer: { value: input.signer ?? null, isWritable: true },
-    owner: { value: input.owner ?? null, isWritable: false },
-    market: { value: input.market ?? null, isWritable: false },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
-    tokenMint: { value: input.tokenMint ?? null, isWritable: false },
-    marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
-    ownerTokenAccount: {
-      value: input.ownerTokenAccount ?? null,
-      isWritable: true
-    },
-    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
-    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
-  };
-  const accounts = originalAccounts;
-  const args = { ...input };
-  if (!accounts.stakeAccount.value) {
-    accounts.stakeAccount.value = await getProgramDerivedAddress17({
-      programAddress,
-      seeds: [
-        getBytesEncoder35().encode(
-          new Uint8Array([
-            115,
-            116,
-            97,
-            107,
-            101,
-            95,
-            97,
-            99,
-            99,
-            111,
-            117,
-            110,
-            116
-          ])
-        ),
-        getAddressEncoder51().encode(expectAddress(accounts.owner.value)),
-        getAddressEncoder51().encode(expectAddress(accounts.market.value)),
-        getU32Encoder22().encode(expectSome(args.stakeAccountId))
-      ]
-    });
-  }
-  if (!accounts.marketTokenAta.value) {
-    accounts.marketTokenAta.value = await getProgramDerivedAddress17({
-      programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
-      seeds: [
-        getAddressEncoder51().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder51().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder51().encode(expectAddress(accounts.tokenMint.value))
-      ]
-    });
-  }
-  if (!accounts.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.signer),
-      getAccountMeta(accounts.owner),
-      getAccountMeta(accounts.market),
-      getAccountMeta(accounts.stakeAccount),
-      getAccountMeta(accounts.tokenMint),
-      getAccountMeta(accounts.marketTokenAta),
-      getAccountMeta(accounts.ownerTokenAccount),
-      getAccountMeta(accounts.tokenProgram),
-      getAccountMeta(accounts.systemProgram)
-    ],
-    data: getUnstakeInstructionDataEncoder().encode(
-      args
-    ),
-    programAddress
-  });
-}
-function getUnstakeInstruction(input, config) {
-  const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    signer: { value: input.signer ?? null, isWritable: true },
-    owner: { value: input.owner ?? null, isWritable: false },
-    market: { value: input.market ?? null, isWritable: false },
-    stakeAccount: { value: input.stakeAccount ?? null, isWritable: true },
-    tokenMint: { value: input.tokenMint ?? null, isWritable: false },
-    marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
-    ownerTokenAccount: {
-      value: input.ownerTokenAccount ?? null,
-      isWritable: true
-    },
-    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
-    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
-  };
-  const accounts = originalAccounts;
-  const args = { ...input };
-  if (!accounts.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.signer),
-      getAccountMeta(accounts.owner),
-      getAccountMeta(accounts.market),
-      getAccountMeta(accounts.stakeAccount),
-      getAccountMeta(accounts.tokenMint),
-      getAccountMeta(accounts.marketTokenAta),
-      getAccountMeta(accounts.ownerTokenAccount),
-      getAccountMeta(accounts.tokenProgram),
-      getAccountMeta(accounts.systemProgram)
-    ],
-    data: getUnstakeInstructionDataEncoder().encode(
-      args
-    ),
-    programAddress
-  });
-}
-function parseUnstakeInstruction(instruction) {
-  if (instruction.accounts.length < 9) {
-    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: {
-      signer: getNextAccount(),
-      owner: getNextAccount(),
-      market: getNextAccount(),
-      stakeAccount: getNextAccount(),
-      tokenMint: getNextAccount(),
-      marketTokenAta: getNextAccount(),
-      ownerTokenAccount: getNextAccount(),
-      tokenProgram: getNextAccount(),
-      systemProgram: getNextAccount()
-    },
-    data: getUnstakeInstructionDataDecoder().decode(instruction.data)
-  };
-}
-
-// src/generated/instructions/updatePlatformConfig.ts
-import {
-  combineCodec as combineCodec87,
-  fixDecoderSize as fixDecoderSize35,
-  fixEncoderSize as fixEncoderSize36,
-  getBytesDecoder as getBytesDecoder35,
-  getBytesEncoder as getBytesEncoder36,
-  getStructDecoder as getStructDecoder81,
-  getStructEncoder as getStructEncoder81,
-  transformEncoder as transformEncoder35
-} from "@solana/kit";
-var UPDATE_PLATFORM_CONFIG_DISCRIMINATOR = new Uint8Array([
-  195,
-  60,
-  76,
-  129,
-  146,
-  45,
-  67,
-  143
+  181,
+  9,
+  219,
+  232,
+  219
 ]);
-function getUpdatePlatformConfigDiscriminatorBytes() {
-  return fixEncoderSize36(getBytesEncoder36(), 8).encode(
-    UPDATE_PLATFORM_CONFIG_DISCRIMINATOR
+function getVouchCompDefDiscriminatorBytes() {
+  return fixEncoderSize35(getBytesEncoder35(), 8).encode(
+    VOUCH_COMP_DEF_DISCRIMINATOR
   );
 }
-function getUpdatePlatformConfigInstructionDataEncoder() {
-  return transformEncoder35(
-    getStructEncoder81([
-      ["discriminator", fixEncoderSize36(getBytesEncoder36(), 8)],
-      ["params", getUpdatePlatformParametersEncoder()]
-    ]),
-    (value) => ({
-      ...value,
-      discriminator: UPDATE_PLATFORM_CONFIG_DISCRIMINATOR
-    })
+function getVouchCompDefInstructionDataEncoder() {
+  return transformEncoder34(
+    getStructEncoder80([["discriminator", fixEncoderSize35(getBytesEncoder35(), 8)]]),
+    (value) => ({ ...value, discriminator: VOUCH_COMP_DEF_DISCRIMINATOR })
   );
 }
-function getUpdatePlatformConfigInstructionDataDecoder() {
-  return getStructDecoder81([
-    ["discriminator", fixDecoderSize35(getBytesDecoder35(), 8)],
-    ["params", getUpdatePlatformParametersDecoder()]
+function getVouchCompDefInstructionDataDecoder() {
+  return getStructDecoder80([
+    ["discriminator", fixDecoderSize34(getBytesDecoder34(), 8)]
   ]);
 }
-function getUpdatePlatformConfigInstructionDataCodec() {
-  return combineCodec87(
-    getUpdatePlatformConfigInstructionDataEncoder(),
-    getUpdatePlatformConfigInstructionDataDecoder()
+function getVouchCompDefInstructionDataCodec() {
+  return combineCodec86(
+    getVouchCompDefInstructionDataEncoder(),
+    getVouchCompDefInstructionDataDecoder()
   );
 }
-function getUpdatePlatformConfigInstruction(input, config) {
+function getVouchCompDefInstruction(input, config) {
   const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
   const originalAccounts = {
-    updateAuthority: {
-      value: input.updateAuthority ?? null,
-      isWritable: false
+    payer: { value: input.payer ?? null, isWritable: true },
+    mxeAccount: { value: input.mxeAccount ?? null, isWritable: true },
+    compDefAccount: { value: input.compDefAccount ?? null, isWritable: true },
+    addressLookupTable: {
+      value: input.addressLookupTable ?? null,
+      isWritable: true
     },
-    platformConfig: { value: input.platformConfig ?? null, isWritable: true }
+    lutProgram: { value: input.lutProgram ?? null, isWritable: false },
+    arciumProgram: { value: input.arciumProgram ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
-  const args = { ...input };
+  if (!accounts.lutProgram.value) {
+    accounts.lutProgram.value = "AddressLookupTab1e1111111111111111111111111";
+  }
+  if (!accounts.arciumProgram.value) {
+    accounts.arciumProgram.value = "Arcj82pX7HxYKLR92qvgZUAd7vGS1k4hQvAFcPATFdEQ";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
   const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
   return Object.freeze({
     accounts: [
-      getAccountMeta(accounts.updateAuthority),
-      getAccountMeta(accounts.platformConfig)
+      getAccountMeta(accounts.payer),
+      getAccountMeta(accounts.mxeAccount),
+      getAccountMeta(accounts.compDefAccount),
+      getAccountMeta(accounts.addressLookupTable),
+      getAccountMeta(accounts.lutProgram),
+      getAccountMeta(accounts.arciumProgram),
+      getAccountMeta(accounts.systemProgram)
     ],
-    data: getUpdatePlatformConfigInstructionDataEncoder().encode(
-      args
-    ),
+    data: getVouchCompDefInstructionDataEncoder().encode({}),
     programAddress
   });
 }
-function parseUpdatePlatformConfigInstruction(instruction) {
-  if (instruction.accounts.length < 2) {
+function parseVouchCompDefInstruction(instruction) {
+  if (instruction.accounts.length < 7) {
     throw new Error("Not enough accounts");
   }
   let accountIndex = 0;
@@ -7422,27 +7231,30 @@ function parseUpdatePlatformConfigInstruction(instruction) {
   return {
     programAddress: instruction.programAddress,
     accounts: {
-      updateAuthority: getNextAccount(),
-      platformConfig: getNextAccount()
+      payer: getNextAccount(),
+      mxeAccount: getNextAccount(),
+      compDefAccount: getNextAccount(),
+      addressLookupTable: getNextAccount(),
+      lutProgram: getNextAccount(),
+      arciumProgram: getNextAccount(),
+      systemProgram: getNextAccount()
     },
-    data: getUpdatePlatformConfigInstructionDataDecoder().decode(
-      instruction.data
-    )
+    data: getVouchCompDefInstructionDataDecoder().decode(instruction.data)
   };
 }
 
 // src/generated/instructions/withdrawReward.ts
 import {
-  combineCodec as combineCodec88,
-  fixDecoderSize as fixDecoderSize36,
-  fixEncoderSize as fixEncoderSize37,
-  getAddressEncoder as getAddressEncoder52,
-  getBytesDecoder as getBytesDecoder36,
-  getBytesEncoder as getBytesEncoder37,
-  getProgramDerivedAddress as getProgramDerivedAddress18,
-  getStructDecoder as getStructDecoder82,
-  getStructEncoder as getStructEncoder82,
-  transformEncoder as transformEncoder36
+  combineCodec as combineCodec87,
+  fixDecoderSize as fixDecoderSize35,
+  fixEncoderSize as fixEncoderSize36,
+  getAddressEncoder as getAddressEncoder51,
+  getBytesDecoder as getBytesDecoder35,
+  getBytesEncoder as getBytesEncoder36,
+  getProgramDerivedAddress as getProgramDerivedAddress17,
+  getStructDecoder as getStructDecoder81,
+  getStructEncoder as getStructEncoder81,
+  transformEncoder as transformEncoder35
 } from "@solana/kit";
 var WITHDRAW_REWARD_DISCRIMINATOR = new Uint8Array([
   191,
@@ -7455,23 +7267,23 @@ var WITHDRAW_REWARD_DISCRIMINATOR = new Uint8Array([
   244
 ]);
 function getWithdrawRewardDiscriminatorBytes() {
-  return fixEncoderSize37(getBytesEncoder37(), 8).encode(
+  return fixEncoderSize36(getBytesEncoder36(), 8).encode(
     WITHDRAW_REWARD_DISCRIMINATOR
   );
 }
 function getWithdrawRewardInstructionDataEncoder() {
-  return transformEncoder36(
-    getStructEncoder82([["discriminator", fixEncoderSize37(getBytesEncoder37(), 8)]]),
+  return transformEncoder35(
+    getStructEncoder81([["discriminator", fixEncoderSize36(getBytesEncoder36(), 8)]]),
     (value) => ({ ...value, discriminator: WITHDRAW_REWARD_DISCRIMINATOR })
   );
 }
 function getWithdrawRewardInstructionDataDecoder() {
-  return getStructDecoder82([
-    ["discriminator", fixDecoderSize36(getBytesDecoder36(), 8)]
+  return getStructDecoder81([
+    ["discriminator", fixDecoderSize35(getBytesDecoder35(), 8)]
   ]);
 }
 function getWithdrawRewardInstructionDataCodec() {
-  return combineCodec88(
+  return combineCodec87(
     getWithdrawRewardInstructionDataEncoder(),
     getWithdrawRewardInstructionDataDecoder()
   );
@@ -7492,24 +7304,24 @@ async function getWithdrawRewardInstructionAsync(input, config) {
   };
   const accounts = originalAccounts;
   if (!accounts.sponsorAccount.value) {
-    accounts.sponsorAccount.value = await getProgramDerivedAddress18({
+    accounts.sponsorAccount.value = await getProgramDerivedAddress17({
       programAddress,
       seeds: [
-        getBytesEncoder37().encode(
+        getBytesEncoder36().encode(
           new Uint8Array([115, 112, 111, 110, 115, 111, 114])
         ),
-        getAddressEncoder52().encode(expectAddress(accounts.sponsor.value)),
-        getAddressEncoder52().encode(expectAddress(accounts.market.value))
+        getAddressEncoder51().encode(expectAddress(accounts.sponsor.value)),
+        getAddressEncoder51().encode(expectAddress(accounts.market.value))
       ]
     });
   }
   if (!accounts.marketTokenAta.value) {
-    accounts.marketTokenAta.value = await getProgramDerivedAddress18({
+    accounts.marketTokenAta.value = await getProgramDerivedAddress17({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder52().encode(expectAddress(accounts.market.value)),
-        getAddressEncoder52().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder52().encode(expectAddress(accounts.tokenMint.value))
+        getAddressEncoder51().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder51().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder51().encode(expectAddress(accounts.tokenMint.value))
       ]
     });
   }
@@ -7583,6 +7395,201 @@ function parseWithdrawRewardInstruction(instruction) {
   };
 }
 
+// src/generated/instructions/withdrawVouch.ts
+import {
+  combineCodec as combineCodec88,
+  fixDecoderSize as fixDecoderSize36,
+  fixEncoderSize as fixEncoderSize37,
+  getAddressEncoder as getAddressEncoder52,
+  getBytesDecoder as getBytesDecoder36,
+  getBytesEncoder as getBytesEncoder37,
+  getProgramDerivedAddress as getProgramDerivedAddress18,
+  getStructDecoder as getStructDecoder82,
+  getStructEncoder as getStructEncoder82,
+  getU32Decoder as getU32Decoder22,
+  getU32Encoder as getU32Encoder22,
+  transformEncoder as transformEncoder36
+} from "@solana/kit";
+var WITHDRAW_VOUCH_DISCRIMINATOR = new Uint8Array([
+  201,
+  33,
+  64,
+  226,
+  252,
+  193,
+  27,
+  83
+]);
+function getWithdrawVouchDiscriminatorBytes() {
+  return fixEncoderSize37(getBytesEncoder37(), 8).encode(
+    WITHDRAW_VOUCH_DISCRIMINATOR
+  );
+}
+function getWithdrawVouchInstructionDataEncoder() {
+  return transformEncoder36(
+    getStructEncoder82([
+      ["discriminator", fixEncoderSize37(getBytesEncoder37(), 8)],
+      ["vouchAccountId", getU32Encoder22()]
+    ]),
+    (value) => ({ ...value, discriminator: WITHDRAW_VOUCH_DISCRIMINATOR })
+  );
+}
+function getWithdrawVouchInstructionDataDecoder() {
+  return getStructDecoder82([
+    ["discriminator", fixDecoderSize36(getBytesDecoder36(), 8)],
+    ["vouchAccountId", getU32Decoder22()]
+  ]);
+}
+function getWithdrawVouchInstructionDataCodec() {
+  return combineCodec88(
+    getWithdrawVouchInstructionDataEncoder(),
+    getWithdrawVouchInstructionDataDecoder()
+  );
+}
+async function getWithdrawVouchInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    signer: { value: input.signer ?? null, isWritable: true },
+    owner: { value: input.owner ?? null, isWritable: false },
+    market: { value: input.market ?? null, isWritable: false },
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true },
+    tokenMint: { value: input.tokenMint ?? null, isWritable: false },
+    marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
+    ownerTokenAccount: {
+      value: input.ownerTokenAccount ?? null,
+      isWritable: true
+    },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.vouchAccount.value) {
+    accounts.vouchAccount.value = await getProgramDerivedAddress18({
+      programAddress,
+      seeds: [
+        getBytesEncoder37().encode(
+          new Uint8Array([
+            118,
+            111,
+            117,
+            99,
+            104,
+            95,
+            97,
+            99,
+            99,
+            111,
+            117,
+            110,
+            116
+          ])
+        ),
+        getAddressEncoder52().encode(expectAddress(accounts.owner.value)),
+        getAddressEncoder52().encode(expectAddress(accounts.market.value)),
+        getU32Encoder22().encode(expectSome(args.vouchAccountId))
+      ]
+    });
+  }
+  if (!accounts.marketTokenAta.value) {
+    accounts.marketTokenAta.value = await getProgramDerivedAddress18({
+      programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+      seeds: [
+        getAddressEncoder52().encode(expectAddress(accounts.market.value)),
+        getAddressEncoder52().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder52().encode(expectAddress(accounts.tokenMint.value))
+      ]
+    });
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.signer),
+      getAccountMeta(accounts.owner),
+      getAccountMeta(accounts.market),
+      getAccountMeta(accounts.vouchAccount),
+      getAccountMeta(accounts.tokenMint),
+      getAccountMeta(accounts.marketTokenAta),
+      getAccountMeta(accounts.ownerTokenAccount),
+      getAccountMeta(accounts.tokenProgram),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    data: getWithdrawVouchInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getWithdrawVouchInstruction(input, config) {
+  const programAddress = config?.programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    signer: { value: input.signer ?? null, isWritable: true },
+    owner: { value: input.owner ?? null, isWritable: false },
+    market: { value: input.market ?? null, isWritable: false },
+    vouchAccount: { value: input.vouchAccount ?? null, isWritable: true },
+    tokenMint: { value: input.tokenMint ?? null, isWritable: false },
+    marketTokenAta: { value: input.marketTokenAta ?? null, isWritable: true },
+    ownerTokenAccount: {
+      value: input.ownerTokenAccount ?? null,
+      isWritable: true
+    },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.signer),
+      getAccountMeta(accounts.owner),
+      getAccountMeta(accounts.market),
+      getAccountMeta(accounts.vouchAccount),
+      getAccountMeta(accounts.tokenMint),
+      getAccountMeta(accounts.marketTokenAta),
+      getAccountMeta(accounts.ownerTokenAccount),
+      getAccountMeta(accounts.tokenProgram),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    data: getWithdrawVouchInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseWithdrawVouchInstruction(instruction) {
+  if (instruction.accounts.length < 9) {
+    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: {
+      signer: getNextAccount(),
+      owner: getNextAccount(),
+      market: getNextAccount(),
+      vouchAccount: getNextAccount(),
+      tokenMint: getNextAccount(),
+      marketTokenAta: getNextAccount(),
+      ownerTokenAccount: getNextAccount(),
+      tokenProgram: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getWithdrawVouchInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
 // src/accounts/opportunityMarket.ts
 import {
   getAddressEncoder as getAddressEncoder53,
@@ -7630,7 +7637,7 @@ async function createMarket(input) {
     authorizedReaderPubkey,
     earlinessCutoffSeconds,
     earlinessMultiplier,
-    minStakeAmount,
+    minVouchAmount,
     creatorFeeClaimer
   } = input;
   const resolvedProgramAddress = programAddress ?? OPPORTUNITY_MARKET_PROGRAM_ADDRESS;
@@ -7653,7 +7660,7 @@ async function createMarket(input) {
         authorizedReaderPubkey: toNumberArray(authorizedReaderPubkey),
         earlinessCutoffSeconds,
         earlinessMultiplier,
-        minStakeAmount,
+        minVouchAmount,
         creatorFeeClaimer
       }
     },
@@ -7676,8 +7683,8 @@ import {
 import { PublicKey } from "@solana/web3.js";
 import { BN } from "bn.js";
 var ALL_COMP_DEF_CIRCUITS = [
-  "stake",
-  "reveal_stake"
+  "vouch",
+  "reveal_vouch"
 ];
 function toAddress(pubkey) {
   return address(pubkey.toBase58());
@@ -7716,10 +7723,10 @@ async function getInitCompDefInstruction(rpc, payer, circuitName, config = {}) {
     addressLookupTable: toAddress(lutAddress)
   };
   switch (circuitName) {
-    case "stake":
-      return getStakeCompDefInstruction(baseInput, { programAddress: programId });
-    case "reveal_stake":
-      return getRevealStakeCompDefInstruction(baseInput, { programAddress: programId });
+    case "vouch":
+      return getVouchCompDefInstruction(baseInput, { programAddress: programId });
+    case "reveal_vouch":
+      return getRevealVouchCompDefInstruction(baseInput, { programAddress: programId });
     default:
       throw new Error(`Unknown circuit: ${circuitName}`);
   }
@@ -7808,15 +7815,15 @@ var awaitComputationFinalization = async (rpc, computationAccount, invocationSig
   }
 };
 
-// src/instructions/stake.ts
-async function stake(input, config) {
+// src/instructions/vouch.ts
+async function vouch(input, config) {
   const {
     programAddress,
     signer,
     payer,
     market,
-    stakeAccount,
-    stakeAccountId,
+    vouchAccount,
+    vouchAccountId,
     tokenMint,
     signerTokenAccount,
     tokenProgram,
@@ -7827,20 +7834,20 @@ async function stake(input, config) {
     userPubkey,
     stateNonce
   } = input;
-  const { computationOffset, ...computeAccounts } = getComputeAccounts("stake", config);
-  return getStakeInstructionAsync(
+  const { computationOffset, ...computeAccounts } = getComputeAccounts("vouch", config);
+  return getVouchInstructionAsync(
     {
       ...computeAccounts,
       signer,
       payer,
       market,
-      stakeAccount,
+      vouchAccount,
       tokenMint,
       signerTokenAccount,
       tokenProgram,
       params: {
         computationOffset,
-        stakeAccountId,
+        vouchAccountId,
         amount,
         selectedOptionCiphertext: toNumberArray(selectedOptionCiphertext),
         inputNonce,
@@ -7852,27 +7859,27 @@ async function stake(input, config) {
     programAddress ? { programAddress } : void 0
   );
 }
-async function awaitStakeFinalization(rpc, txSignature, config, options) {
-  const { computationAccount } = getComputeAccounts("stake", config);
+async function awaitVouchFinalization(rpc, txSignature, config, options) {
+  const { computationAccount } = getComputeAccounts("vouch", config);
   return awaitComputationFinalization(rpc, computationAccount, txSignature, options);
 }
 
-// src/instructions/revealStake.ts
-async function revealStake(input, config) {
-  const { programAddress, signer, owner, market, stakeAccountId } = input;
-  return getRevealStakeInstructionAsync(
+// src/instructions/revealVouch.ts
+async function revealVouch(input, config) {
+  const { programAddress, signer, owner, market, vouchAccountId } = input;
+  return getRevealVouchInstructionAsync(
     {
-      ...getComputeAccounts("reveal_stake", config),
+      ...getComputeAccounts("reveal_vouch", config),
       signer,
       owner,
       market,
-      stakeAccountId
+      vouchAccountId
     },
     programAddress ? { programAddress } : void 0
   );
 }
-async function awaitRevealStakeFinalization(rpc, txSignature, config, options) {
-  const { computationAccount } = getComputeAccounts("reveal_stake", config);
+async function awaitRevealVouchFinalization(rpc, txSignature, config, options) {
+  const { computationAccount } = getComputeAccounts("reveal_vouch", config);
   return awaitComputationFinalization(rpc, computationAccount, txSignature, options);
 }
 
@@ -7930,10 +7937,10 @@ async function addReward(input) {
   );
 }
 
-// src/instructions/initStakeAccount.ts
-async function initStakeAccount(input) {
+// src/instructions/initVouchAccount.ts
+async function initVouchAccount(input) {
   const { programAddress, ...params } = input;
-  return getInitStakeAccountInstructionAsync(
+  return getInitVouchAccountInstructionAsync(
     params,
     programAddress ? { programAddress } : void 0
   );
@@ -7957,28 +7964,28 @@ async function claimRewards(input) {
   );
 }
 
-// src/instructions/closeStakeAccount.ts
-async function closeStakeAccount(input) {
+// src/instructions/closeVouchAccount.ts
+async function closeVouchAccount(input) {
   const { programAddress, ...params } = input;
-  return getCloseStakeAccountInstructionAsync(
+  return getCloseVouchAccountInstructionAsync(
     params,
     programAddress ? { programAddress } : void 0
   );
 }
 
-// src/instructions/closeUnrevealedStakeAccount.ts
-async function closeUnrevealedStakeAccount(input) {
+// src/instructions/closeUnrevealedVouchAccount.ts
+async function closeUnrevealedVouchAccount(input) {
   const { programAddress, ...params } = input;
-  return getCloseUnrevealedStakeAccountInstructionAsync(
+  return getCloseUnrevealedVouchAccountInstructionAsync(
     params,
     programAddress ? { programAddress } : void 0
   );
 }
 
-// src/instructions/closeStuckStakeAccount.ts
-async function closeStuckStakeAccount(input) {
+// src/instructions/closeStuckVouchAccount.ts
+async function closeStuckVouchAccount(input) {
   const { programAddress, ...params } = input;
-  return getCloseStuckStakeAccountInstructionAsync(
+  return getCloseStuckVouchAccountInstructionAsync(
     params,
     programAddress ? { programAddress } : void 0
   );
@@ -7993,19 +8000,19 @@ async function closeOptionAccount(input) {
   );
 }
 
-// src/instructions/unstake.ts
-async function unstake(input) {
+// src/instructions/withdrawVouch.ts
+async function withdrawVouch(input) {
   const { programAddress, ...params } = input;
-  return getUnstakeInstructionAsync(
+  return getWithdrawVouchInstructionAsync(
     params,
     programAddress ? { programAddress } : void 0
   );
 }
 
-// src/instructions/finalizeRevealStake.ts
-async function finalizeRevealStake(input) {
+// src/instructions/finalizeRevealVouch.ts
+async function finalizeRevealVouch(input) {
   const { programAddress, ...params } = input;
-  return getFinalizeRevealStakeInstructionAsync(
+  return getFinalizeRevealVouchInstructionAsync(
     params,
     programAddress ? { programAddress } : void 0
   );
@@ -8040,7 +8047,7 @@ async function createPlatformConfig(rpc, params) {
     creatorFeeBp,
     feeClaimAuthority,
     revealAuthority,
-    minTimeToStakeSeconds,
+    minTimeToVouchSeconds,
     revealPeriodSeconds,
     marketResolutionDeadlineSeconds
   } = params;
@@ -8066,7 +8073,7 @@ async function createPlatformConfig(rpc, params) {
         creatorFeeBp,
         feeClaimAuthority,
         revealAuthority,
-        minTimeToStakeSeconds,
+        minTimeToVouchSeconds,
         revealPeriodSeconds,
         marketResolutionDeadlineSeconds
       }
@@ -8085,7 +8092,7 @@ async function updatePlatformConfig(rpc, params) {
     rewardPoolFeeBp,
     creatorFeeBp,
     revealAuthority,
-    minTimeToStakeSeconds,
+    minTimeToVouchSeconds,
     revealPeriodSeconds,
     marketResolutionDeadlineSeconds
   } = params;
@@ -8109,7 +8116,7 @@ async function updatePlatformConfig(rpc, params) {
         rewardPoolFeeBp,
         creatorFeeBp,
         revealAuthority,
-        minTimeToStakeSeconds,
+        minTimeToVouchSeconds,
         revealPeriodSeconds,
         marketResolutionDeadlineSeconds
       }
@@ -8213,20 +8220,20 @@ async function getOpportunityMarketSponsorAddress(sponsor, market, programId = O
   });
 }
 
-// src/accounts/stakeAccount.ts
+// src/accounts/vouchAccount.ts
 import {
   getAddressEncoder as getAddressEncoder58,
   getProgramDerivedAddress as getProgramDerivedAddress24
 } from "@solana/kit";
-var STAKE_ACCOUNT_SEED = "stake_account";
-async function getStakeAccountAddress(owner, market, stakeAccountId, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
+var VOUCH_ACCOUNT_SEED = "vouch_account";
+async function getVouchAccountAddress(owner, market, vouchAccountId, programId = OPPORTUNITY_MARKET_PROGRAM_ADDRESS) {
   const addressEncoder = getAddressEncoder58();
   const idBytes = new Uint8Array(4);
-  new DataView(idBytes.buffer).setUint32(0, stakeAccountId, true);
+  new DataView(idBytes.buffer).setUint32(0, vouchAccountId, true);
   return getProgramDerivedAddress24({
     programAddress: programId,
     seeds: [
-      STAKE_ACCOUNT_SEED,
+      VOUCH_ACCOUNT_SEED,
       addressEncoder.encode(owner),
       addressEncoder.encode(market),
       idBytes
@@ -8269,22 +8276,22 @@ export {
   CLAIM_FEES_DISCRIMINATOR,
   CLAIM_REWARDS_DISCRIMINATOR,
   CLOSE_OPTION_ACCOUNT_DISCRIMINATOR,
-  CLOSE_STAKE_ACCOUNT_DISCRIMINATOR,
-  CLOSE_STUCK_STAKE_ACCOUNT_DISCRIMINATOR,
-  CLOSE_UNREVEALED_STAKE_ACCOUNT_DISCRIMINATOR,
+  CLOSE_STUCK_VOUCH_ACCOUNT_DISCRIMINATOR,
+  CLOSE_UNREVEALED_VOUCH_ACCOUNT_DISCRIMINATOR,
+  CLOSE_VOUCH_ACCOUNT_DISCRIMINATOR,
   CREATE_MARKET_DISCRIMINATOR,
   END_REVEAL_PERIOD_DISCRIMINATOR,
-  FINALIZE_REVEAL_STAKE_DISCRIMINATOR,
+  FINALIZE_REVEAL_VOUCH_DISCRIMINATOR,
   INIT_ALLOWED_MINT_DISCRIMINATOR,
   INIT_PLATFORM_CONFIG_DISCRIMINATOR,
-  INIT_STAKE_ACCOUNT_DISCRIMINATOR,
+  INIT_VOUCH_ACCOUNT_DISCRIMINATOR,
   LocalCircuitSource,
   MxeStatus,
   OPEN_MARKET_DISCRIMINATOR,
   OPPORTUNITY_MARKET_DISCRIMINATOR,
   OPPORTUNITY_MARKET_ERROR__ALREADY_REVEALED,
-  OPPORTUNITY_MARKET_ERROR__ALREADY_STAKED,
-  OPPORTUNITY_MARKET_ERROR__ALREADY_UNSTAKED,
+  OPPORTUNITY_MARKET_ERROR__ALREADY_VOUCHED,
+  OPPORTUNITY_MARKET_ERROR__ALREADY_VOUCH_WITHDRAWN,
   OPPORTUNITY_MARKET_ERROR__CREATOR_MISMATCH,
   OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_BALANCE,
   OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_REWARD_FUNDING,
@@ -8298,14 +8305,14 @@ export {
   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__NO_VOUCH,
   OPPORTUNITY_MARKET_ERROR__OPTION_STILL_NEEDED,
   OPPORTUNITY_MARKET_ERROR__OVERFLOW,
   OPPORTUNITY_MARKET_ERROR__REWARD_ALREADY_CLAIMED,
-  OPPORTUNITY_MARKET_ERROR__STAKE_BELOW_MINIMUM,
-  OPPORTUNITY_MARKET_ERROR__STAKE_NOT_STUCK,
   OPPORTUNITY_MARKET_ERROR__TALLY_ALREADY_INCREMENTED,
   OPPORTUNITY_MARKET_ERROR__UNAUTHORIZED,
+  OPPORTUNITY_MARKET_ERROR__VOUCH_BELOW_MINIMUM,
+  OPPORTUNITY_MARKET_ERROR__VOUCH_NOT_STUCK,
   OPPORTUNITY_MARKET_ERROR__WINNER_ALREADY_SELECTED,
   OPPORTUNITY_MARKET_ERROR__WRONG_MARKET_PHASE,
   OPPORTUNITY_MARKET_OPTION_DISCRIMINATOR,
@@ -8320,34 +8327,34 @@ export {
   PLATFORM_CONFIG_SEED,
   Parameter,
   RESOLVE_MARKET_DISCRIMINATOR,
-  REVEAL_STAKE_CALLBACK_DISCRIMINATOR,
-  REVEAL_STAKE_COMP_DEF_DISCRIMINATOR,
-  REVEAL_STAKE_DISCRIMINATOR,
+  REVEAL_VOUCH_CALLBACK_DISCRIMINATOR,
+  REVEAL_VOUCH_COMP_DEF_DISCRIMINATOR,
+  REVEAL_VOUCH_DISCRIMINATOR,
   SET_FEE_CLAIM_AUTHORITY_DISCRIMINATOR,
   SET_UPDATE_AUTHORITY_DISCRIMINATOR,
   SET_WINNING_OPTION_DISCRIMINATOR,
   SPONSOR_SEED,
-  STAKE_ACCOUNT_DISCRIMINATOR,
-  STAKE_ACCOUNT_SEED,
-  STAKE_CALLBACK_DISCRIMINATOR,
-  STAKE_COMP_DEF_DISCRIMINATOR,
-  STAKE_DISCRIMINATOR,
-  UNSTAKE_DISCRIMINATOR,
   UPDATE_PLATFORM_CONFIG_DISCRIMINATOR,
+  VOUCH_ACCOUNT_DISCRIMINATOR,
+  VOUCH_ACCOUNT_SEED,
+  VOUCH_CALLBACK_DISCRIMINATOR,
+  VOUCH_COMP_DEF_DISCRIMINATOR,
+  VOUCH_DISCRIMINATOR,
   WITHDRAW_REWARD_DISCRIMINATOR,
+  WITHDRAW_VOUCH_DISCRIMINATOR,
   addMarketOption,
   addReward,
   awaitComputationFinalization,
-  awaitRevealStakeFinalization,
-  awaitStakeFinalization,
+  awaitRevealVouchFinalization,
+  awaitVouchFinalization,
   circuitSource,
   claimCreatorFees,
   claimFees,
   claimRewards,
   closeOptionAccount,
-  closeStakeAccount,
-  closeStuckStakeAccount,
-  closeUnrevealedStakeAccount,
+  closeStuckVouchAccount,
+  closeUnrevealedVouchAccount,
+  closeVouchAccount,
   createCipher,
   createMarket,
   createPlatformConfig,
@@ -8357,7 +8364,7 @@ export {
   decodeOpportunityMarketOption,
   decodeOpportunityMarketSponsor,
   decodePlatformConfig,
-  decodeStakeAccount,
+  decodeVouchAccount,
   deriveSharedSecret,
   deriveX25519KeypairFromSignature,
   endRevealPeriod,
@@ -8369,12 +8376,12 @@ export {
   fetchAllMaybeOpportunityMarketOption,
   fetchAllMaybeOpportunityMarketSponsor,
   fetchAllMaybePlatformConfig,
-  fetchAllMaybeStakeAccount,
+  fetchAllMaybeVouchAccount,
   fetchAllOpportunityMarket,
   fetchAllOpportunityMarketOption,
   fetchAllOpportunityMarketSponsor,
   fetchAllPlatformConfig,
-  fetchAllStakeAccount,
+  fetchAllVouchAccount,
   fetchAllowedMint,
   fetchArciumSignerAccount,
   fetchMaybeAllowedMint,
@@ -8383,13 +8390,13 @@ export {
   fetchMaybeOpportunityMarketOption,
   fetchMaybeOpportunityMarketSponsor,
   fetchMaybePlatformConfig,
-  fetchMaybeStakeAccount,
+  fetchMaybeVouchAccount,
   fetchOpportunityMarket,
   fetchOpportunityMarketOption,
   fetchOpportunityMarketSponsor,
   fetchPlatformConfig,
-  fetchStakeAccount,
-  finalizeRevealStake,
+  fetchVouchAccount,
+  finalizeRevealVouch,
   generateX25519Keypair,
   getActivationCodec,
   getActivationDecoder,
@@ -8451,24 +8458,24 @@ export {
   getCloseOptionAccountInstructionDataCodec,
   getCloseOptionAccountInstructionDataDecoder,
   getCloseOptionAccountInstructionDataEncoder,
-  getCloseStakeAccountDiscriminatorBytes,
-  getCloseStakeAccountInstruction,
-  getCloseStakeAccountInstructionAsync,
-  getCloseStakeAccountInstructionDataCodec,
-  getCloseStakeAccountInstructionDataDecoder,
-  getCloseStakeAccountInstructionDataEncoder,
-  getCloseStuckStakeAccountDiscriminatorBytes,
-  getCloseStuckStakeAccountInstruction,
-  getCloseStuckStakeAccountInstructionAsync,
-  getCloseStuckStakeAccountInstructionDataCodec,
-  getCloseStuckStakeAccountInstructionDataDecoder,
-  getCloseStuckStakeAccountInstructionDataEncoder,
-  getCloseUnrevealedStakeAccountDiscriminatorBytes,
-  getCloseUnrevealedStakeAccountInstruction,
-  getCloseUnrevealedStakeAccountInstructionAsync,
-  getCloseUnrevealedStakeAccountInstructionDataCodec,
-  getCloseUnrevealedStakeAccountInstructionDataDecoder,
-  getCloseUnrevealedStakeAccountInstructionDataEncoder,
+  getCloseStuckVouchAccountDiscriminatorBytes,
+  getCloseStuckVouchAccountInstruction,
+  getCloseStuckVouchAccountInstructionAsync,
+  getCloseStuckVouchAccountInstructionDataCodec,
+  getCloseStuckVouchAccountInstructionDataDecoder,
+  getCloseStuckVouchAccountInstructionDataEncoder,
+  getCloseUnrevealedVouchAccountDiscriminatorBytes,
+  getCloseUnrevealedVouchAccountInstruction,
+  getCloseUnrevealedVouchAccountInstructionAsync,
+  getCloseUnrevealedVouchAccountInstructionDataCodec,
+  getCloseUnrevealedVouchAccountInstructionDataDecoder,
+  getCloseUnrevealedVouchAccountInstructionDataEncoder,
+  getCloseVouchAccountDiscriminatorBytes,
+  getCloseVouchAccountInstruction,
+  getCloseVouchAccountInstructionAsync,
+  getCloseVouchAccountInstructionDataCodec,
+  getCloseVouchAccountInstructionDataDecoder,
+  getCloseVouchAccountInstructionDataEncoder,
   getClusterCodec,
   getClusterDecoder,
   getClusterEncoder,
@@ -8518,12 +8525,12 @@ export {
   getFeesClaimedEventCodec,
   getFeesClaimedEventDecoder,
   getFeesClaimedEventEncoder,
-  getFinalizeRevealStakeDiscriminatorBytes,
-  getFinalizeRevealStakeInstruction,
-  getFinalizeRevealStakeInstructionAsync,
-  getFinalizeRevealStakeInstructionDataCodec,
-  getFinalizeRevealStakeInstructionDataDecoder,
-  getFinalizeRevealStakeInstructionDataEncoder,
+  getFinalizeRevealVouchDiscriminatorBytes,
+  getFinalizeRevealVouchInstruction,
+  getFinalizeRevealVouchInstructionAsync,
+  getFinalizeRevealVouchInstructionDataCodec,
+  getFinalizeRevealVouchInstructionDataDecoder,
+  getFinalizeRevealVouchInstructionDataEncoder,
   getInitAllowedMintDiscriminatorBytes,
   getInitAllowedMintInstruction,
   getInitAllowedMintInstructionAsync,
@@ -8539,12 +8546,12 @@ export {
   getInitPlatformParametersCodec,
   getInitPlatformParametersDecoder,
   getInitPlatformParametersEncoder,
-  getInitStakeAccountDiscriminatorBytes,
-  getInitStakeAccountInstruction,
-  getInitStakeAccountInstructionAsync,
-  getInitStakeAccountInstructionDataCodec,
-  getInitStakeAccountInstructionDataDecoder,
-  getInitStakeAccountInstructionDataEncoder,
+  getInitVouchAccountDiscriminatorBytes,
+  getInitVouchAccountInstruction,
+  getInitVouchAccountInstructionAsync,
+  getInitVouchAccountInstructionDataCodec,
+  getInitVouchAccountInstructionDataDecoder,
+  getInitVouchAccountInstructionDataEncoder,
   getLocalCircuitSourceCodec,
   getLocalCircuitSourceDecoder,
   getLocalCircuitSourceEncoder,
@@ -8622,28 +8629,28 @@ export {
   getRevealPeriodEndedEventCodec,
   getRevealPeriodEndedEventDecoder,
   getRevealPeriodEndedEventEncoder,
-  getRevealStakeCallbackDiscriminatorBytes,
-  getRevealStakeCallbackInstruction,
-  getRevealStakeCallbackInstructionDataCodec,
-  getRevealStakeCallbackInstructionDataDecoder,
-  getRevealStakeCallbackInstructionDataEncoder,
-  getRevealStakeCompDefDiscriminatorBytes,
-  getRevealStakeCompDefInstruction,
-  getRevealStakeCompDefInstructionDataCodec,
-  getRevealStakeCompDefInstructionDataDecoder,
-  getRevealStakeCompDefInstructionDataEncoder,
-  getRevealStakeDiscriminatorBytes,
-  getRevealStakeFinalizedEventCodec,
-  getRevealStakeFinalizedEventDecoder,
-  getRevealStakeFinalizedEventEncoder,
-  getRevealStakeInstruction,
-  getRevealStakeInstructionAsync,
-  getRevealStakeInstructionDataCodec,
-  getRevealStakeInstructionDataDecoder,
-  getRevealStakeInstructionDataEncoder,
-  getRevealStakeOutputCodec,
-  getRevealStakeOutputDecoder,
-  getRevealStakeOutputEncoder,
+  getRevealVouchCallbackDiscriminatorBytes,
+  getRevealVouchCallbackInstruction,
+  getRevealVouchCallbackInstructionDataCodec,
+  getRevealVouchCallbackInstructionDataDecoder,
+  getRevealVouchCallbackInstructionDataEncoder,
+  getRevealVouchCompDefDiscriminatorBytes,
+  getRevealVouchCompDefInstruction,
+  getRevealVouchCompDefInstructionDataCodec,
+  getRevealVouchCompDefInstructionDataDecoder,
+  getRevealVouchCompDefInstructionDataEncoder,
+  getRevealVouchDiscriminatorBytes,
+  getRevealVouchFinalizedEventCodec,
+  getRevealVouchFinalizedEventDecoder,
+  getRevealVouchFinalizedEventEncoder,
+  getRevealVouchInstruction,
+  getRevealVouchInstructionAsync,
+  getRevealVouchInstructionDataCodec,
+  getRevealVouchInstructionDataDecoder,
+  getRevealVouchInstructionDataEncoder,
+  getRevealVouchOutputCodec,
+  getRevealVouchOutputDecoder,
+  getRevealVouchOutputEncoder,
   getRewardAddedEventCodec,
   getRewardAddedEventDecoder,
   getRewardAddedEventEncoder,
@@ -8669,63 +8676,12 @@ export {
   getSetWinningOptionInstructionDataCodec,
   getSetWinningOptionInstructionDataDecoder,
   getSetWinningOptionInstructionDataEncoder,
-  getStakeAccountAddress,
-  getStakeAccountClosedEventCodec,
-  getStakeAccountClosedEventDecoder,
-  getStakeAccountClosedEventEncoder,
-  getStakeAccountCodec,
-  getStakeAccountDecoder,
-  getStakeAccountDiscriminatorBytes,
-  getStakeAccountEncoder,
-  getStakeAccountInitializedEventCodec,
-  getStakeAccountInitializedEventDecoder,
-  getStakeAccountInitializedEventEncoder,
-  getStakeCallbackDiscriminatorBytes,
-  getStakeCallbackInstruction,
-  getStakeCallbackInstructionDataCodec,
-  getStakeCallbackInstructionDataDecoder,
-  getStakeCallbackInstructionDataEncoder,
-  getStakeCompDefDiscriminatorBytes,
-  getStakeCompDefInstruction,
-  getStakeCompDefInstructionDataCodec,
-  getStakeCompDefInstructionDataDecoder,
-  getStakeCompDefInstructionDataEncoder,
-  getStakeDiscriminatorBytes,
-  getStakeInstruction,
-  getStakeInstructionAsync,
-  getStakeInstructionDataCodec,
-  getStakeInstructionDataDecoder,
-  getStakeInstructionDataEncoder,
-  getStakeOutputCodec,
-  getStakeOutputDecoder,
-  getStakeOutputEncoder,
-  getStakeOutputStruct0Codec,
-  getStakeOutputStruct0Decoder,
-  getStakeOutputStruct0Encoder,
-  getStakeParametersCodec,
-  getStakeParametersDecoder,
-  getStakeParametersEncoder,
-  getStakeRevealedEventCodec,
-  getStakeRevealedEventDecoder,
-  getStakeRevealedEventEncoder,
-  getStakedEventCodec,
-  getStakedEventDecoder,
-  getStakedEventEncoder,
-  getStuckStakeClosedEventCodec,
-  getStuckStakeClosedEventDecoder,
-  getStuckStakeClosedEventEncoder,
+  getStuckVouchClosedEventCodec,
+  getStuckVouchClosedEventDecoder,
+  getStuckVouchClosedEventEncoder,
   getTimestampCodec,
   getTimestampDecoder,
   getTimestampEncoder,
-  getUnstakeDiscriminatorBytes,
-  getUnstakeInstruction,
-  getUnstakeInstructionAsync,
-  getUnstakeInstructionDataCodec,
-  getUnstakeInstructionDataDecoder,
-  getUnstakeInstructionDataEncoder,
-  getUnstakedEventCodec,
-  getUnstakedEventDecoder,
-  getUnstakedEventEncoder,
   getUpdateAuthorityChangedEventCodec,
   getUpdateAuthorityChangedEventDecoder,
   getUpdateAuthorityChangedEventEncoder,
@@ -8740,6 +8696,51 @@ export {
   getUtilityPubkeysCodec,
   getUtilityPubkeysDecoder,
   getUtilityPubkeysEncoder,
+  getVouchAccountAddress,
+  getVouchAccountClosedEventCodec,
+  getVouchAccountClosedEventDecoder,
+  getVouchAccountClosedEventEncoder,
+  getVouchAccountCodec,
+  getVouchAccountDecoder,
+  getVouchAccountDiscriminatorBytes,
+  getVouchAccountEncoder,
+  getVouchAccountInitializedEventCodec,
+  getVouchAccountInitializedEventDecoder,
+  getVouchAccountInitializedEventEncoder,
+  getVouchCallbackDiscriminatorBytes,
+  getVouchCallbackInstruction,
+  getVouchCallbackInstructionDataCodec,
+  getVouchCallbackInstructionDataDecoder,
+  getVouchCallbackInstructionDataEncoder,
+  getVouchCompDefDiscriminatorBytes,
+  getVouchCompDefInstruction,
+  getVouchCompDefInstructionDataCodec,
+  getVouchCompDefInstructionDataDecoder,
+  getVouchCompDefInstructionDataEncoder,
+  getVouchDiscriminatorBytes,
+  getVouchInstruction,
+  getVouchInstructionAsync,
+  getVouchInstructionDataCodec,
+  getVouchInstructionDataDecoder,
+  getVouchInstructionDataEncoder,
+  getVouchOutputCodec,
+  getVouchOutputDecoder,
+  getVouchOutputEncoder,
+  getVouchOutputStruct0Codec,
+  getVouchOutputStruct0Decoder,
+  getVouchOutputStruct0Encoder,
+  getVouchParametersCodec,
+  getVouchParametersDecoder,
+  getVouchParametersEncoder,
+  getVouchRevealedEventCodec,
+  getVouchRevealedEventDecoder,
+  getVouchRevealedEventEncoder,
+  getVouchWithdrawnEventCodec,
+  getVouchWithdrawnEventDecoder,
+  getVouchWithdrawnEventEncoder,
+  getVouchedEventCodec,
+  getVouchedEventDecoder,
+  getVouchedEventEncoder,
   getWinningOptionSetEventCodec,
   getWinningOptionSetEventDecoder,
   getWinningOptionSetEventEncoder,
@@ -8749,10 +8750,16 @@ export {
   getWithdrawRewardInstructionDataCodec,
   getWithdrawRewardInstructionDataDecoder,
   getWithdrawRewardInstructionDataEncoder,
+  getWithdrawVouchDiscriminatorBytes,
+  getWithdrawVouchInstruction,
+  getWithdrawVouchInstructionAsync,
+  getWithdrawVouchInstructionDataCodec,
+  getWithdrawVouchInstructionDataDecoder,
+  getWithdrawVouchInstructionDataEncoder,
   identifyOpportunityMarketAccount,
   identifyOpportunityMarketInstruction,
   initAllowedMint,
-  initStakeAccount,
+  initVouchAccount,
   isCircuitSource,
   isOpportunityMarketError,
   nonceToBytes,
@@ -8763,40 +8770,40 @@ export {
   parseClaimFeesInstruction,
   parseClaimRewardsInstruction,
   parseCloseOptionAccountInstruction,
-  parseCloseStakeAccountInstruction,
-  parseCloseStuckStakeAccountInstruction,
-  parseCloseUnrevealedStakeAccountInstruction,
+  parseCloseStuckVouchAccountInstruction,
+  parseCloseUnrevealedVouchAccountInstruction,
+  parseCloseVouchAccountInstruction,
   parseCreateMarketInstruction,
   parseEndRevealPeriodInstruction,
-  parseFinalizeRevealStakeInstruction,
+  parseFinalizeRevealVouchInstruction,
   parseInitAllowedMintInstruction,
   parseInitPlatformConfigInstruction,
-  parseInitStakeAccountInstruction,
+  parseInitVouchAccountInstruction,
   parseOpenMarketInstruction,
   parseResolveMarketInstruction,
-  parseRevealStakeCallbackInstruction,
-  parseRevealStakeCompDefInstruction,
-  parseRevealStakeInstruction,
+  parseRevealVouchCallbackInstruction,
+  parseRevealVouchCompDefInstruction,
+  parseRevealVouchInstruction,
   parseSetFeeClaimAuthorityInstruction,
   parseSetUpdateAuthorityInstruction,
   parseSetWinningOptionInstruction,
-  parseStakeCallbackInstruction,
-  parseStakeCompDefInstruction,
-  parseStakeInstruction,
-  parseUnstakeInstruction,
   parseUpdatePlatformConfigInstruction,
+  parseVouchCallbackInstruction,
+  parseVouchCompDefInstruction,
+  parseVouchInstruction,
   parseWithdrawRewardInstruction,
+  parseWithdrawVouchInstruction,
   randomComputationOffset,
   randomStateNonce,
   resolveMarket,
-  revealStake,
+  revealVouch,
   setFeeClaimAuthority,
   setUpdateAuthority,
   setWinningOption,
-  stake,
   toNumberArray,
-  unstake,
   updatePlatformConfig,
-  withdrawReward
+  vouch,
+  withdrawReward,
+  withdrawVouch
 };
 //# sourceMappingURL=index.js.map