@bench.games/opportunity-markets 0.2.13 → 0.3.0

package/dist/index.d.cts

@@ -1,5 +1,4 @@
-import { ReadonlyUint8Array, EncodedAccount, Account, MaybeEncodedAccount, MaybeAccount, fetchEncodedAccounts, Address, FetchAccountsConfig, fetchEncodedAccount, FetchAccountConfig, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder, Codec, Decoder, Encoder, GetDiscriminatedUnionVariantContent, GetDiscriminatedUnionVariant, Option, OptionOrNullable, SolanaError, SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM, TransactionSigner, AccountMeta, Instruction, InstructionWithData, InstructionWithAccounts, WritableSignerAccount, AccountSignerMeta, WritableAccount, ReadonlyAccount, ReadonlySignerAccount, Rpc, SolanaRpcApi, ProgramDerivedAddress } from '@solana/kit';
-import * as _solana_accounts from '@solana/accounts';
+import { ReadonlyUint8Array, Address, EncodedAccount, Account, MaybeEncodedAccount, MaybeAccount, fetchEncodedAccounts, FetchAccountsConfig, fetchEncodedAccount, FetchAccountConfig, FixedSizeCodec, FixedSizeDecoder, FixedSizeEncoder, GetDiscriminatedUnionVariantContent, GetDiscriminatedUnionVariant, Codec, Decoder, Encoder, Option, OptionOrNullable, SolanaError, SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM, TransactionSigner, AccountMeta, Instruction, InstructionWithData, InstructionWithAccounts, WritableSignerAccount, AccountSignerMeta, WritableAccount, ReadonlyAccount, ReadonlySignerAccount, Rpc, SolanaRpcApi, ProgramDerivedAddress } from '@solana/kit';
 import { RescueCipher } from '@arcium-hq/client';
 
 /**
@@ -10,24 +9,28 @@ import { RescueCipher } from '@arcium-hq/client';
  * @see https://github.com/codama-idl/codama
  */
 
-declare const ARCIUM_SIGNER_ACCOUNT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getArciumSignerAccountDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type ArciumSignerAccount = {
+declare const ALLOWED_MINT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getAllowedMintDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type AllowedMint = {
     discriminator: ReadonlyUint8Array;
     bump: number;
+    platform: Address;
+    mint: Address;
 };
-type ArciumSignerAccountArgs = {
+type AllowedMintArgs = {
     bump: number;
+    platform: Address;
+    mint: Address;
 };
-declare function getArciumSignerAccountEncoder(): FixedSizeEncoder<ArciumSignerAccountArgs>;
-declare function getArciumSignerAccountDecoder(): FixedSizeDecoder<ArciumSignerAccount>;
-declare function getArciumSignerAccountCodec(): FixedSizeCodec<ArciumSignerAccountArgs, ArciumSignerAccount>;
-declare function decodeArciumSignerAccount<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<ArciumSignerAccount, TAddress>;
-declare function decodeArciumSignerAccount<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<ArciumSignerAccount, TAddress>;
-declare function fetchArciumSignerAccount<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<ArciumSignerAccount, TAddress>>;
-declare function fetchMaybeArciumSignerAccount<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<ArciumSignerAccount, TAddress>>;
-declare function fetchAllArciumSignerAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<ArciumSignerAccount>[]>;
-declare function fetchAllMaybeArciumSignerAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<ArciumSignerAccount>[]>;
+declare function getAllowedMintEncoder(): FixedSizeEncoder<AllowedMintArgs>;
+declare function getAllowedMintDecoder(): FixedSizeDecoder<AllowedMint>;
+declare function getAllowedMintCodec(): FixedSizeCodec<AllowedMintArgs, AllowedMint>;
+declare function decodeAllowedMint<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<AllowedMint, TAddress>;
+declare function decodeAllowedMint<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<AllowedMint, TAddress>;
+declare function fetchAllowedMint<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<AllowedMint, TAddress>>;
+declare function fetchMaybeAllowedMint<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<AllowedMint, TAddress>>;
+declare function fetchAllAllowedMint(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<AllowedMint>[]>;
+declare function fetchAllMaybeAllowedMint(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<AllowedMint>[]>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -37,60 +40,24 @@ declare function fetchAllMaybeArciumSignerAccount(rpc: Parameters<typeof fetchEn
  * @see https://github.com/codama-idl/codama
  */
 
-declare const CENTRAL_STATE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getCentralStateDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type CentralState = {
+declare const ARCIUM_SIGNER_ACCOUNT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getArciumSignerAccountDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type ArciumSignerAccount = {
     discriminator: ReadonlyUint8Array;
     bump: number;
-    updateAuthority: Address;
-    protocolFeeBp: number;
-    feeClaimer: Address;
-    /** Reserved for future use */
-    reserved: Array<number>;
 };
-type CentralStateArgs = {
+type ArciumSignerAccountArgs = {
     bump: number;
-    updateAuthority: Address;
-    protocolFeeBp: number;
-    feeClaimer: Address;
-    /** Reserved for future use */
-    reserved: Array<number>;
-};
-declare function getCentralStateEncoder(): FixedSizeEncoder<CentralStateArgs>;
-declare function getCentralStateDecoder(): FixedSizeDecoder<CentralState>;
-declare function getCentralStateCodec(): FixedSizeCodec<CentralStateArgs, CentralState>;
-declare function decodeCentralState<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<CentralState, TAddress>;
-declare function decodeCentralState<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<CentralState, TAddress>;
-declare function fetchCentralState<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<CentralState, TAddress>>;
-declare function fetchMaybeCentralState<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<CentralState, TAddress>>;
-declare function fetchAllCentralState(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<CentralState>[]>;
-declare function fetchAllMaybeCentralState(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<CentralState>[]>;
-
-/**
- * This code was AUTOGENERATED using the Codama library.
- * Please DO NOT EDIT THIS FILE, instead use visitors
- * to add features, then rerun Codama to update it.
- *
- * @see https://github.com/codama-idl/codama
- */
-
-type AccountChangeCancelledEvent = {
-    centralState: Address;
-    changeType: string;
-    cancelledBy: Address;
-    proposedValue: Address;
-    timestamp: bigint;
-};
-type AccountChangeCancelledEventArgs = {
-    centralState: Address;
-    changeType: string;
-    cancelledBy: Address;
-    proposedValue: Address;
-    timestamp: number | bigint;
 };
-declare function getAccountChangeCancelledEventEncoder(): Encoder<AccountChangeCancelledEventArgs>;
-declare function getAccountChangeCancelledEventDecoder(): Decoder<AccountChangeCancelledEvent>;
-declare function getAccountChangeCancelledEventCodec(): Codec<AccountChangeCancelledEventArgs, AccountChangeCancelledEvent>;
+declare function getArciumSignerAccountEncoder(): FixedSizeEncoder<ArciumSignerAccountArgs>;
+declare function getArciumSignerAccountDecoder(): FixedSizeDecoder<ArciumSignerAccount>;
+declare function getArciumSignerAccountCodec(): FixedSizeCodec<ArciumSignerAccountArgs, ArciumSignerAccount>;
+declare function decodeArciumSignerAccount<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<ArciumSignerAccount, TAddress>;
+declare function decodeArciumSignerAccount<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<ArciumSignerAccount, TAddress>;
+declare function fetchArciumSignerAccount<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<ArciumSignerAccount, TAddress>>;
+declare function fetchMaybeArciumSignerAccount<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<ArciumSignerAccount, TAddress>>;
+declare function fetchAllArciumSignerAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<ArciumSignerAccount>[]>;
+declare function fetchAllMaybeArciumSignerAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<ArciumSignerAccount>[]>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -100,23 +67,17 @@ declare function getAccountChangeCancelledEventCodec(): Codec<AccountChangeCance
  * @see https://github.com/codama-idl/codama
  */
 
-type AccountChangeFinalizedEvent = {
-    centralState: Address;
-    changeType: string;
-    oldValue: Address;
-    newValue: Address;
-    timestamp: bigint;
+type Activation = {
+    activationEpoch: Epoch;
+    deactivationEpoch: Epoch;
 };
-type AccountChangeFinalizedEventArgs = {
-    centralState: Address;
-    changeType: string;
-    oldValue: Address;
-    newValue: Address;
-    timestamp: number | bigint;
+type ActivationArgs = {
+    activationEpoch: EpochArgs;
+    deactivationEpoch: EpochArgs;
 };
-declare function getAccountChangeFinalizedEventEncoder(): Encoder<AccountChangeFinalizedEventArgs>;
-declare function getAccountChangeFinalizedEventDecoder(): Decoder<AccountChangeFinalizedEvent>;
-declare function getAccountChangeFinalizedEventCodec(): Codec<AccountChangeFinalizedEventArgs, AccountChangeFinalizedEvent>;
+declare function getActivationEncoder(): FixedSizeEncoder<ActivationArgs>;
+declare function getActivationDecoder(): FixedSizeDecoder<Activation>;
+declare function getActivationCodec(): FixedSizeCodec<ActivationArgs, Activation>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -126,45 +87,21 @@ declare function getAccountChangeFinalizedEventCodec(): Codec<AccountChangeFinal
  * @see https://github.com/codama-idl/codama
  */
 
-type AccountChangeProposedEvent = {
-    centralState: Address;
-    changeType: string;
-    currentValue: Address;
-    proposedValue: Address;
-    executeAfter: bigint;
+type AllowedMintInitializedEvent = {
+    allowedMint: Address;
+    platform: Address;
+    mint: Address;
     timestamp: bigint;
 };
-type AccountChangeProposedEventArgs = {
-    centralState: Address;
-    changeType: string;
-    currentValue: Address;
-    proposedValue: Address;
-    executeAfter: number | bigint;
+type AllowedMintInitializedEventArgs = {
+    allowedMint: Address;
+    platform: Address;
+    mint: Address;
     timestamp: number | bigint;
 };
-declare function getAccountChangeProposedEventEncoder(): Encoder<AccountChangeProposedEventArgs>;
-declare function getAccountChangeProposedEventDecoder(): Decoder<AccountChangeProposedEvent>;
-declare function getAccountChangeProposedEventCodec(): Codec<AccountChangeProposedEventArgs, AccountChangeProposedEvent>;
-
-/**
- * This code was AUTOGENERATED using the Codama library.
- * Please DO NOT EDIT THIS FILE, instead use visitors
- * to add features, then rerun Codama to update it.
- *
- * @see https://github.com/codama-idl/codama
- */
-
-type Activation = {
-    activationEpoch: Epoch;
-    deactivationEpoch: Epoch;
-};
-type ActivationArgs = {
-    activationEpoch: EpochArgs;
-    deactivationEpoch: EpochArgs;
-};
-declare function getActivationEncoder(): FixedSizeEncoder<ActivationArgs>;
-declare function getActivationDecoder(): FixedSizeDecoder<Activation>;
-declare function getActivationCodec(): FixedSizeCodec<ActivationArgs, Activation>;
+declare function getAllowedMintInitializedEventEncoder(): FixedSizeEncoder<AllowedMintInitializedEventArgs>;
+declare function getAllowedMintInitializedEventDecoder(): FixedSizeDecoder<AllowedMintInitializedEvent>;
+declare function getAllowedMintInitializedEventCodec(): FixedSizeCodec<AllowedMintInitializedEventArgs, AllowedMintInitializedEvent>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -218,6 +155,134 @@ declare function isCircuitSource<K extends CircuitSource['__kind']>(kind: K, val
     __kind: K;
 };
 
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+/** An account storing the current network epoch */
+type ClockAccount = {
+    startEpoch: Epoch;
+    currentEpoch: Epoch;
+    startEpochTimestamp: Timestamp;
+    bump: number;
+};
+type ClockAccountArgs = {
+    startEpoch: EpochArgs;
+    currentEpoch: EpochArgs;
+    startEpochTimestamp: TimestampArgs;
+    bump: number;
+};
+declare function getClockAccountEncoder(): FixedSizeEncoder<ClockAccountArgs>;
+declare function getClockAccountDecoder(): FixedSizeDecoder<ClockAccount>;
+declare function getClockAccountCodec(): FixedSizeCodec<ClockAccountArgs, ClockAccount>;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type Cluster = {
+    tdInfo: Option<NodeMetadata>;
+    authority: Option<Address>;
+    clusterSize: number;
+    activation: Activation;
+    maxCapacity: bigint;
+    cuPrice: bigint;
+    cuPriceProposals: Array<bigint>;
+    lastUpdatedEpoch: Epoch;
+    nodes: Array<NodeRef>;
+    pendingNodes: Array<number>;
+    blsPublicKey: {
+        __kind: 'Set';
+        fields: readonly [BN254G2BLSPublicKey];
+    } | {
+        __kind: 'Unset';
+        fields: readonly [BN254G2BLSPublicKey, Array<boolean>];
+    };
+    bump: number;
+};
+type ClusterArgs = {
+    tdInfo: OptionOrNullable<NodeMetadataArgs>;
+    authority: OptionOrNullable<Address>;
+    clusterSize: number;
+    activation: ActivationArgs;
+    maxCapacity: number | bigint;
+    cuPrice: number | bigint;
+    cuPriceProposals: Array<number | bigint>;
+    lastUpdatedEpoch: EpochArgs;
+    nodes: Array<NodeRefArgs>;
+    pendingNodes: Array<number>;
+    blsPublicKey: {
+        __kind: 'Set';
+        fields: readonly [BN254G2BLSPublicKeyArgs];
+    } | {
+        __kind: 'Unset';
+        fields: readonly [BN254G2BLSPublicKeyArgs, Array<boolean>];
+    };
+    bump: number;
+};
+declare function getClusterEncoder(): Encoder<ClusterArgs>;
+declare function getClusterDecoder(): Decoder<Cluster>;
+declare function getClusterCodec(): Codec<ClusterArgs, Cluster>;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type CollectedFees = {
+    platformFee: bigint;
+    rewardPoolFee: bigint;
+    creatorFee: bigint;
+};
+type CollectedFeesArgs = {
+    platformFee: number | bigint;
+    rewardPoolFee: number | bigint;
+    creatorFee: number | bigint;
+};
+declare function getCollectedFeesEncoder(): FixedSizeEncoder<CollectedFeesArgs>;
+declare function getCollectedFeesDecoder(): FixedSizeDecoder<CollectedFees>;
+declare function getCollectedFeesCodec(): FixedSizeCodec<CollectedFeesArgs, CollectedFees>;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+/** An account representing a [ComputationDefinition] in a MXE. */
+type ComputationDefinitionAccount = {
+    deactivationSlot: Option<bigint>;
+    cuAmount: bigint;
+    definition: ComputationDefinitionMeta;
+    circuitSource: CircuitSource;
+    bump: number;
+    padding: Array<number>;
+};
+type ComputationDefinitionAccountArgs = {
+    deactivationSlot: OptionOrNullable<number | bigint>;
+    cuAmount: number | bigint;
+    definition: ComputationDefinitionMetaArgs;
+    circuitSource: CircuitSourceArgs;
+    bump: number;
+    padding: Array<number>;
+};
+declare function getComputationDefinitionAccountEncoder(): Encoder<ComputationDefinitionAccountArgs>;
+declare function getComputationDefinitionAccountDecoder(): Decoder<ComputationDefinitionAccount>;
+declare function getComputationDefinitionAccountCodec(): Codec<ComputationDefinitionAccountArgs, ComputationDefinitionAccount>;
+
 /**
  * This code was AUTOGENERATED using the Codama library.
  * Please DO NOT EDIT THIS FILE, instead use visitors
@@ -260,6 +325,34 @@ declare function getComputationSignatureEncoder(): Encoder<ComputationSignatureA
 declare function getComputationSignatureDecoder(): Decoder<ComputationSignature>;
 declare function getComputationSignatureCodec(): Codec<ComputationSignatureArgs, ComputationSignature>;
 
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type CreatorFeesClaimedEvent = {
+    market: Address;
+    creatorFeeClaimer: Address;
+    mint: Address;
+    destination: Address;
+    amount: bigint;
+    timestamp: bigint;
+};
+type CreatorFeesClaimedEventArgs = {
+    market: Address;
+    creatorFeeClaimer: Address;
+    mint: Address;
+    destination: Address;
+    amount: number | bigint;
+    timestamp: number | bigint;
+};
+declare function getCreatorFeesClaimedEventEncoder(): FixedSizeEncoder<CreatorFeesClaimedEventArgs>;
+declare function getCreatorFeesClaimedEventDecoder(): FixedSizeDecoder<CreatorFeesClaimedEvent>;
+declare function getCreatorFeesClaimedEventCodec(): FixedSizeCodec<CreatorFeesClaimedEventArgs, CreatorFeesClaimedEvent>;
+
 /**
  * This code was AUTOGENERATED using the Codama library.
  * Please DO NOT EDIT THIS FILE, instead use visitors
@@ -275,6 +368,64 @@ declare function getEpochEncoder(): FixedSizeEncoder<EpochArgs>;
 declare function getEpochDecoder(): FixedSizeDecoder<Epoch>;
 declare function getEpochCodec(): FixedSizeCodec<EpochArgs, Epoch>;
 
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type FeeClaimAuthorityChangedEvent = {
+    platformConfig: Address;
+    oldValue: Address;
+    newValue: Address;
+    timestamp: bigint;
+};
+type FeeClaimAuthorityChangedEventArgs = {
+    platformConfig: Address;
+    oldValue: Address;
+    newValue: Address;
+    timestamp: number | bigint;
+};
+declare function getFeeClaimAuthorityChangedEventEncoder(): FixedSizeEncoder<FeeClaimAuthorityChangedEventArgs>;
+declare function getFeeClaimAuthorityChangedEventDecoder(): FixedSizeDecoder<FeeClaimAuthorityChangedEvent>;
+declare function getFeeClaimAuthorityChangedEventCodec(): FixedSizeCodec<FeeClaimAuthorityChangedEventArgs, FeeClaimAuthorityChangedEvent>;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type FeePool = {
+    bump: number;
+};
+type FeePoolArgs = FeePool;
+declare function getFeePoolEncoder(): FixedSizeEncoder<FeePoolArgs>;
+declare function getFeePoolDecoder(): FixedSizeDecoder<FeePool>;
+declare function getFeePoolCodec(): FixedSizeCodec<FeePoolArgs, FeePool>;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type FeeRates = {
+    platformFeeBp: number;
+    rewardPoolFeeBp: number;
+    creatorFeeBp: number;
+};
+type FeeRatesArgs = FeeRates;
+declare function getFeeRatesEncoder(): FixedSizeEncoder<FeeRatesArgs>;
+declare function getFeeRatesDecoder(): FixedSizeDecoder<FeeRates>;
+declare function getFeeRatesCodec(): FixedSizeCodec<FeeRatesArgs, FeeRates>;
+
 /**
  * This code was AUTOGENERATED using the Codama library.
  * Please DO NOT EDIT THIS FILE, instead use visitors
@@ -284,14 +435,16 @@ declare function getEpochCodec(): FixedSizeCodec<EpochArgs, Epoch>;
  */
 
 type FeesClaimedEvent = {
-    tokenVault: Address;
+    market: Address;
+    platform: Address;
     mint: Address;
     destination: Address;
     amount: bigint;
     timestamp: bigint;
 };
 type FeesClaimedEventArgs = {
-    tokenVault: Address;
+    market: Address;
+    platform: Address;
     mint: Address;
     destination: Address;
     amount: number | bigint;
@@ -330,34 +483,44 @@ declare function getLocalCircuitSourceCodec(): FixedSizeCodec<LocalCircuitSource
 type MarketCreatedEvent = {
     market: Address;
     creator: Address;
+    platform: Address;
     index: bigint;
     mint: Address;
-    timeToStake: bigint;
-    timeToReveal: bigint;
     earlinessCutoffSeconds: bigint;
-    marketAuthority: Option<Address>;
+    earlinessMultiplier: number;
+    marketAuthority: Address;
     authorizedReaderPubkey: Array<number>;
-    unstakeDelaySeconds: bigint;
-    allowClosingEarly: boolean;
+    allowUnstakingEarly: boolean;
+    minStakeAmount: bigint;
+    feeRates: FeeRates;
+    creatorFeeClaimer: Address;
+    marketResolutionDeadlineSeconds: bigint;
+    minRevealPeriodSeconds: bigint;
+    maxRevealPeriodSeconds: bigint;
     timestamp: bigint;
 };
 type MarketCreatedEventArgs = {
     market: Address;
     creator: Address;
+    platform: Address;
     index: number | bigint;
     mint: Address;
-    timeToStake: number | bigint;
-    timeToReveal: number | bigint;
     earlinessCutoffSeconds: number | bigint;
-    marketAuthority: OptionOrNullable<Address>;
+    earlinessMultiplier: number;
+    marketAuthority: Address;
     authorizedReaderPubkey: Array<number>;
-    unstakeDelaySeconds: number | bigint;
-    allowClosingEarly: boolean;
+    allowUnstakingEarly: boolean;
+    minStakeAmount: number | bigint;
+    feeRates: FeeRatesArgs;
+    creatorFeeClaimer: Address;
+    marketResolutionDeadlineSeconds: number | bigint;
+    minRevealPeriodSeconds: number | bigint;
+    maxRevealPeriodSeconds: number | bigint;
     timestamp: number | bigint;
 };
-declare function getMarketCreatedEventEncoder(): Encoder<MarketCreatedEventArgs>;
-declare function getMarketCreatedEventDecoder(): Decoder<MarketCreatedEvent>;
-declare function getMarketCreatedEventCodec(): Codec<MarketCreatedEventArgs, MarketCreatedEvent>;
+declare function getMarketCreatedEventEncoder(): FixedSizeEncoder<MarketCreatedEventArgs>;
+declare function getMarketCreatedEventDecoder(): FixedSizeDecoder<MarketCreatedEvent>;
+declare function getMarketCreatedEventCodec(): FixedSizeCodec<MarketCreatedEventArgs, MarketCreatedEvent>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -370,13 +533,13 @@ declare function getMarketCreatedEventCodec(): Codec<MarketCreatedEventArgs, Mar
 type MarketOpenedEvent = {
     market: Address;
     creator: Address;
-    openTimestamp: bigint;
+    stakeEndTimestamp: bigint;
     timestamp: bigint;
 };
 type MarketOpenedEventArgs = {
     market: Address;
     creator: Address;
-    openTimestamp: number | bigint;
+    stakeEndTimestamp: number | bigint;
     timestamp: number | bigint;
 };
 declare function getMarketOpenedEventEncoder(): FixedSizeEncoder<MarketOpenedEventArgs>;
@@ -394,14 +557,14 @@ declare function getMarketOpenedEventCodec(): FixedSizeCodec<MarketOpenedEventAr
 type MarketOptionCreatedEvent = {
     option: Address;
     market: Address;
-    creator: Address;
+    signer: Address;
     id: bigint;
     timestamp: bigint;
 };
 type MarketOptionCreatedEventArgs = {
     option: Address;
     market: Address;
-    creator: Address;
+    signer: Address;
     id: number | bigint;
     timestamp: number | bigint;
 };
@@ -417,17 +580,19 @@ declare function getMarketOptionCreatedEventCodec(): FixedSizeCodec<MarketOption
  * @see https://github.com/codama-idl/codama
  */
 
-type MarketPausedEvent = {
+type MarketResolvedEvent = {
     market: Address;
+    marketAuthority: Address;
     timestamp: bigint;
 };
-type MarketPausedEventArgs = {
+type MarketResolvedEventArgs = {
     market: Address;
+    marketAuthority: Address;
     timestamp: number | bigint;
 };
-declare function getMarketPausedEventEncoder(): FixedSizeEncoder<MarketPausedEventArgs>;
-declare function getMarketPausedEventDecoder(): FixedSizeDecoder<MarketPausedEvent>;
-declare function getMarketPausedEventCodec(): FixedSizeCodec<MarketPausedEventArgs, MarketPausedEvent>;
+declare function getMarketResolvedEventEncoder(): FixedSizeEncoder<MarketResolvedEventArgs>;
+declare function getMarketResolvedEventDecoder(): FixedSizeDecoder<MarketResolvedEvent>;
+declare function getMarketResolvedEventCodec(): FixedSizeCodec<MarketResolvedEventArgs, MarketResolvedEvent>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -437,17 +602,48 @@ declare function getMarketPausedEventCodec(): FixedSizeCodec<MarketPausedEventAr
  * @see https://github.com/codama-idl/codama
  */
 
-type MarketResumedEvent = {
-    market: Address;
-    timestamp: bigint;
+/** A MPC Execution Environment. */
+type MXEAccount = {
+    padding: number;
+    cluster: number;
+    keygenOffset: bigint;
+    keyRecoveryInitOffset: bigint;
+    mxeProgramId: Address;
+    authority: Option<Address>;
+    utilityPubkeys: {
+        __kind: 'Set';
+        fields: readonly [UtilityPubkeys];
+    } | {
+        __kind: 'Unset';
+        fields: readonly [UtilityPubkeys, Array<boolean>];
+    };
+    lutOffsetSlot: bigint;
+    computationDefinitions: Array<number>;
+    status: MxeStatus;
+    bump: number;
 };
-type MarketResumedEventArgs = {
-    market: Address;
-    timestamp: number | bigint;
+type MXEAccountArgs = {
+    padding: number;
+    cluster: number;
+    keygenOffset: number | bigint;
+    keyRecoveryInitOffset: number | bigint;
+    mxeProgramId: Address;
+    authority: OptionOrNullable<Address>;
+    utilityPubkeys: {
+        __kind: 'Set';
+        fields: readonly [UtilityPubkeysArgs];
+    } | {
+        __kind: 'Unset';
+        fields: readonly [UtilityPubkeysArgs, Array<boolean>];
+    };
+    lutOffsetSlot: number | bigint;
+    computationDefinitions: Array<number>;
+    status: MxeStatusArgs;
+    bump: number;
 };
-declare function getMarketResumedEventEncoder(): FixedSizeEncoder<MarketResumedEventArgs>;
-declare function getMarketResumedEventDecoder(): FixedSizeDecoder<MarketResumedEvent>;
-declare function getMarketResumedEventCodec(): FixedSizeCodec<MarketResumedEventArgs, MarketResumedEvent>;
+declare function getMXEAccountEncoder(): Encoder<MXEAccountArgs>;
+declare function getMXEAccountDecoder(): Decoder<MXEAccount>;
+declare function getMXEAccountCodec(): Codec<MXEAccountArgs, MXEAccount>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -543,10 +739,38 @@ type OnChainCircuitSource = {
     isCompleted: boolean;
     uploadAuth: Address;
 };
-type OnChainCircuitSourceArgs = OnChainCircuitSource;
-declare function getOnChainCircuitSourceEncoder(): FixedSizeEncoder<OnChainCircuitSourceArgs>;
-declare function getOnChainCircuitSourceDecoder(): FixedSizeDecoder<OnChainCircuitSource>;
-declare function getOnChainCircuitSourceCodec(): FixedSizeCodec<OnChainCircuitSourceArgs, OnChainCircuitSource>;
+type OnChainCircuitSourceArgs = OnChainCircuitSource;
+declare function getOnChainCircuitSourceEncoder(): FixedSizeEncoder<OnChainCircuitSourceArgs>;
+declare function getOnChainCircuitSourceDecoder(): FixedSizeDecoder<OnChainCircuitSource>;
+declare function getOnChainCircuitSourceCodec(): FixedSizeCodec<OnChainCircuitSourceArgs, OnChainCircuitSource>;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type OptionClosedEvent = {
+    option: Address;
+    optionId: bigint;
+    signer: Address;
+    creator: Address;
+    market: Address;
+    timestamp: bigint;
+};
+type OptionClosedEventArgs = {
+    option: Address;
+    optionId: number | bigint;
+    signer: Address;
+    creator: Address;
+    market: Address;
+    timestamp: number | bigint;
+};
+declare function getOptionClosedEventEncoder(): FixedSizeEncoder<OptionClosedEventArgs>;
+declare function getOptionClosedEventDecoder(): FixedSizeDecoder<OptionClosedEvent>;
+declare function getOptionClosedEventCodec(): FixedSizeCodec<OptionClosedEventArgs, OptionClosedEvent>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -631,18 +855,54 @@ declare function getParameterCodec(): FixedSizeCodec<ParameterArgs, Parameter>;
 
 type RevealPeriodEndedEvent = {
     market: Address;
-    authority: Address;
+    signer: Address;
     timestamp: bigint;
 };
 type RevealPeriodEndedEventArgs = {
     market: Address;
-    authority: Address;
+    signer: Address;
     timestamp: number | bigint;
 };
 declare function getRevealPeriodEndedEventEncoder(): FixedSizeEncoder<RevealPeriodEndedEventArgs>;
 declare function getRevealPeriodEndedEventDecoder(): FixedSizeDecoder<RevealPeriodEndedEvent>;
 declare function getRevealPeriodEndedEventCodec(): FixedSizeCodec<RevealPeriodEndedEventArgs, RevealPeriodEndedEvent>;
 
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type RevealStakeFinalizedEvent = {
+    owner: Address;
+    market: Address;
+    stakeAccount: Address;
+    stakeAccountId: number;
+    optionId: bigint;
+    userStake: bigint;
+    userScore: bigint;
+    totalScore: bigint;
+    totalStake: bigint;
+    timestamp: bigint;
+};
+type RevealStakeFinalizedEventArgs = {
+    owner: Address;
+    market: Address;
+    stakeAccount: Address;
+    stakeAccountId: number;
+    optionId: number | bigint;
+    userStake: number | bigint;
+    userScore: number | bigint;
+    totalScore: number | bigint;
+    totalStake: number | bigint;
+    timestamp: number | bigint;
+};
+declare function getRevealStakeFinalizedEventEncoder(): FixedSizeEncoder<RevealStakeFinalizedEventArgs>;
+declare function getRevealStakeFinalizedEventDecoder(): FixedSizeDecoder<RevealStakeFinalizedEvent>;
+declare function getRevealStakeFinalizedEventCodec(): FixedSizeCodec<RevealStakeFinalizedEventArgs, RevealStakeFinalizedEvent>;
+
 /**
  * This code was AUTOGENERATED using the Codama library.
  * Please DO NOT EDIT THIS FILE, instead use visitors
@@ -877,34 +1137,6 @@ declare function getStakeOutputStruct0Encoder(): FixedSizeEncoder<StakeOutputStr
 declare function getStakeOutputStruct0Decoder(): FixedSizeDecoder<StakeOutputStruct0>;
 declare function getStakeOutputStruct0Codec(): FixedSizeCodec<StakeOutputStruct0Args, StakeOutputStruct0>;
 
-/**
- * This code was AUTOGENERATED using the Codama library.
- * Please DO NOT EDIT THIS FILE, instead use visitors
- * to add features, then rerun Codama to update it.
- *
- * @see https://github.com/codama-idl/codama
- */
-
-type StakeReclaimedEvent = {
-    owner: Address;
-    market: Address;
-    stakeAccount: Address;
-    stakeAccountId: number;
-    amount: bigint;
-    timestamp: bigint;
-};
-type StakeReclaimedEventArgs = {
-    owner: Address;
-    market: Address;
-    stakeAccount: Address;
-    stakeAccountId: number;
-    amount: number | bigint;
-    timestamp: number | bigint;
-};
-declare function getStakeReclaimedEventEncoder(): FixedSizeEncoder<StakeReclaimedEventArgs>;
-declare function getStakeReclaimedEventDecoder(): FixedSizeDecoder<StakeReclaimedEvent>;
-declare function getStakeReclaimedEventCodec(): FixedSizeCodec<StakeReclaimedEventArgs, StakeReclaimedEvent>;
-
 /**
  * This code was AUTOGENERATED using the Codama library.
  * Please DO NOT EDIT THIS FILE, instead use visitors
@@ -943,27 +1175,17 @@ declare function getStakeRevealedEventCodec(): FixedSizeCodec<StakeRevealedEvent
  * @see https://github.com/codama-idl/codama
  */
 
-type StuckStakeClosedEvent = {
-    owner: Address;
+type StakingPausedEvent = {
     market: Address;
-    stakeAccount: Address;
-    stakeAccountId: number;
-    refundedAmount: bigint;
-    refundedFee: bigint;
     timestamp: bigint;
 };
-type StuckStakeClosedEventArgs = {
-    owner: Address;
+type StakingPausedEventArgs = {
     market: Address;
-    stakeAccount: Address;
-    stakeAccountId: number;
-    refundedAmount: number | bigint;
-    refundedFee: number | bigint;
     timestamp: number | bigint;
 };
-declare function getStuckStakeClosedEventEncoder(): FixedSizeEncoder<StuckStakeClosedEventArgs>;
-declare function getStuckStakeClosedEventDecoder(): FixedSizeDecoder<StuckStakeClosedEvent>;
-declare function getStuckStakeClosedEventCodec(): FixedSizeCodec<StuckStakeClosedEventArgs, StuckStakeClosedEvent>;
+declare function getStakingPausedEventEncoder(): FixedSizeEncoder<StakingPausedEventArgs>;
+declare function getStakingPausedEventDecoder(): FixedSizeDecoder<StakingPausedEvent>;
+declare function getStakingPausedEventCodec(): FixedSizeCodec<StakingPausedEventArgs, StakingPausedEvent>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -973,51 +1195,17 @@ declare function getStuckStakeClosedEventCodec(): FixedSizeCodec<StuckStakeClose
  * @see https://github.com/codama-idl/codama
  */
 
-type TallyIncrementedEvent = {
-    owner: Address;
+type StakingResumedEvent = {
     market: Address;
-    stakeAccount: Address;
-    stakeAccountId: number;
-    optionId: bigint;
-    userStake: bigint;
-    userScore: bigint;
-    totalScore: bigint;
-    totalStake: bigint;
     timestamp: bigint;
 };
-type TallyIncrementedEventArgs = {
-    owner: Address;
+type StakingResumedEventArgs = {
     market: Address;
-    stakeAccount: Address;
-    stakeAccountId: number;
-    optionId: number | bigint;
-    userStake: number | bigint;
-    userScore: number | bigint;
-    totalScore: number | bigint;
-    totalStake: number | bigint;
-    timestamp: number | bigint;
-};
-declare function getTallyIncrementedEventEncoder(): FixedSizeEncoder<TallyIncrementedEventArgs>;
-declare function getTallyIncrementedEventDecoder(): FixedSizeDecoder<TallyIncrementedEvent>;
-declare function getTallyIncrementedEventCodec(): FixedSizeCodec<TallyIncrementedEventArgs, TallyIncrementedEvent>;
-
-/**
- * This code was AUTOGENERATED using the Codama library.
- * Please DO NOT EDIT THIS FILE, instead use visitors
- * to add features, then rerun Codama to update it.
- *
- * @see https://github.com/codama-idl/codama
- */
-
-type Timestamp = {
-    timestamp: bigint;
-};
-type TimestampArgs = {
     timestamp: number | bigint;
 };
-declare function getTimestampEncoder(): FixedSizeEncoder<TimestampArgs>;
-declare function getTimestampDecoder(): FixedSizeDecoder<Timestamp>;
-declare function getTimestampCodec(): FixedSizeCodec<TimestampArgs, Timestamp>;
+declare function getStakingResumedEventEncoder(): FixedSizeEncoder<StakingResumedEventArgs>;
+declare function getStakingResumedEventDecoder(): FixedSizeDecoder<StakingResumedEvent>;
+declare function getStakingResumedEventCodec(): FixedSizeCodec<StakingResumedEventArgs, StakingResumedEvent>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -1027,23 +1215,31 @@ declare function getTimestampCodec(): FixedSizeCodec<TimestampArgs, Timestamp>;
  * @see https://github.com/codama-idl/codama
  */
 
-type UnstakedEvent = {
-    user: Address;
+type StuckStakeClosedEvent = {
+    owner: Address;
     market: Address;
     stakeAccount: Address;
     stakeAccountId: number;
+    refundedAmount: bigint;
+    refundedPlatformFee: bigint;
+    refundedRewardPoolFee: bigint;
+    refundedCreatorFee: bigint;
     timestamp: bigint;
 };
-type UnstakedEventArgs = {
-    user: Address;
+type StuckStakeClosedEventArgs = {
+    owner: Address;
     market: Address;
     stakeAccount: Address;
     stakeAccountId: number;
+    refundedAmount: number | bigint;
+    refundedPlatformFee: number | bigint;
+    refundedRewardPoolFee: number | bigint;
+    refundedCreatorFee: number | bigint;
     timestamp: number | bigint;
 };
-declare function getUnstakedEventEncoder(): FixedSizeEncoder<UnstakedEventArgs>;
-declare function getUnstakedEventDecoder(): FixedSizeDecoder<UnstakedEvent>;
-declare function getUnstakedEventCodec(): FixedSizeCodec<UnstakedEventArgs, UnstakedEvent>;
+declare function getStuckStakeClosedEventEncoder(): FixedSizeEncoder<StuckStakeClosedEventArgs>;
+declare function getStuckStakeClosedEventDecoder(): FixedSizeDecoder<StuckStakeClosedEvent>;
+declare function getStuckStakeClosedEventCodec(): FixedSizeCodec<StuckStakeClosedEventArgs, StuckStakeClosedEvent>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -1053,64 +1249,15 @@ declare function getUnstakedEventCodec(): FixedSizeCodec<UnstakedEventArgs, Unst
  * @see https://github.com/codama-idl/codama
  */
 
-type UnstakeInitiatedEvent = {
-    user: Address;
-    market: Address;
-    stakeAccount: Address;
-    stakeAccountId: number;
-    unstakeableAtTimestamp: bigint;
+type Timestamp = {
     timestamp: bigint;
 };
-type UnstakeInitiatedEventArgs = {
-    user: Address;
-    market: Address;
-    stakeAccount: Address;
-    stakeAccountId: number;
-    unstakeableAtTimestamp: number | bigint;
+type TimestampArgs = {
     timestamp: number | bigint;
 };
-declare function getUnstakeInitiatedEventEncoder(): FixedSizeEncoder<UnstakeInitiatedEventArgs>;
-declare function getUnstakeInitiatedEventDecoder(): FixedSizeDecoder<UnstakeInitiatedEvent>;
-declare function getUnstakeInitiatedEventCodec(): FixedSizeCodec<UnstakeInitiatedEventArgs, UnstakeInitiatedEvent>;
-
-/**
- * This code was AUTOGENERATED using the Codama library.
- * Please DO NOT EDIT THIS FILE, instead use visitors
- * to add features, then rerun Codama to update it.
- *
- * @see https://github.com/codama-idl/codama
- */
-
-type UtilityPubkeys = {
-    x25519Pubkey: Array<number>;
-    ed25519VerifyingKey: Array<number>;
-    elgamalPubkey: Array<number>;
-    pubkeyValidityProof: Array<number>;
-};
-type UtilityPubkeysArgs = UtilityPubkeys;
-declare function getUtilityPubkeysEncoder(): FixedSizeEncoder<UtilityPubkeysArgs>;
-declare function getUtilityPubkeysDecoder(): FixedSizeDecoder<UtilityPubkeys>;
-declare function getUtilityPubkeysCodec(): FixedSizeCodec<UtilityPubkeysArgs, UtilityPubkeys>;
-
-/**
- * This code was AUTOGENERATED using the Codama library.
- * Please DO NOT EDIT THIS FILE, instead use visitors
- * to add features, then rerun Codama to update it.
- *
- * @see https://github.com/codama-idl/codama
- */
-
-type WinningOption = {
-    optionId: bigint;
-    rewardPercentage: number;
-};
-type WinningOptionArgs = {
-    optionId: number | bigint;
-    rewardPercentage: number;
-};
-declare function getWinningOptionEncoder(): FixedSizeEncoder<WinningOptionArgs>;
-declare function getWinningOptionDecoder(): FixedSizeDecoder<WinningOption>;
-declare function getWinningOptionCodec(): FixedSizeCodec<WinningOptionArgs, WinningOption>;
+declare function getTimestampEncoder(): FixedSizeEncoder<TimestampArgs>;
+declare function getTimestampDecoder(): FixedSizeDecoder<Timestamp>;
+declare function getTimestampCodec(): FixedSizeCodec<TimestampArgs, Timestamp>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -1120,115 +1267,25 @@ declare function getWinningOptionCodec(): FixedSizeCodec<WinningOptionArgs, Winn
  * @see https://github.com/codama-idl/codama
  */
 
-type WinningOptionsSelectedEvent = {
+type UnstakedEvent = {
+    owner: Address;
     market: Address;
-    authority: Address;
-    selectedOptions: Array<WinningOption>;
+    stakeAccount: Address;
+    stakeAccountId: number;
+    amount: bigint;
     timestamp: bigint;
 };
-type WinningOptionsSelectedEventArgs = {
+type UnstakedEventArgs = {
+    owner: Address;
     market: Address;
-    authority: Address;
-    selectedOptions: Array<WinningOptionArgs>;
-    timestamp: number | bigint;
-};
-declare function getWinningOptionsSelectedEventEncoder(): Encoder<WinningOptionsSelectedEventArgs>;
-declare function getWinningOptionsSelectedEventDecoder(): Decoder<WinningOptionsSelectedEvent>;
-declare function getWinningOptionsSelectedEventCodec(): Codec<WinningOptionsSelectedEventArgs, WinningOptionsSelectedEvent>;
-
-/**
- * This code was AUTOGENERATED using the Codama library.
- * Please DO NOT EDIT THIS FILE, instead use visitors
- * to add features, then rerun Codama to update it.
- *
- * @see https://github.com/codama-idl/codama
- */
-
-declare const CLOCK_ACCOUNT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getClockAccountDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type ClockAccount = {
-    discriminator: ReadonlyUint8Array;
-    startEpoch: Epoch;
-    currentEpoch: Epoch;
-    startEpochTimestamp: Timestamp;
-    bump: number;
-};
-type ClockAccountArgs = {
-    startEpoch: EpochArgs;
-    currentEpoch: EpochArgs;
-    startEpochTimestamp: TimestampArgs;
-    bump: number;
-};
-declare function getClockAccountEncoder(): FixedSizeEncoder<ClockAccountArgs>;
-declare function getClockAccountDecoder(): FixedSizeDecoder<ClockAccount>;
-declare function getClockAccountCodec(): FixedSizeCodec<ClockAccountArgs, ClockAccount>;
-declare function decodeClockAccount<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<ClockAccount, TAddress>;
-declare function decodeClockAccount<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<ClockAccount, TAddress>;
-declare function fetchClockAccount<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<ClockAccount, TAddress>>;
-declare function fetchMaybeClockAccount<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<ClockAccount, TAddress>>;
-declare function fetchAllClockAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<ClockAccount>[]>;
-declare function fetchAllMaybeClockAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<ClockAccount>[]>;
-
-/**
- * This code was AUTOGENERATED using the Codama library.
- * Please DO NOT EDIT THIS FILE, instead use visitors
- * to add features, then rerun Codama to update it.
- *
- * @see https://github.com/codama-idl/codama
- */
-
-declare const CLUSTER_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getClusterDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type Cluster = {
-    discriminator: ReadonlyUint8Array;
-    tdInfo: Option<NodeMetadata>;
-    authority: Option<Address>;
-    clusterSize: number;
-    activation: Activation;
-    maxCapacity: bigint;
-    cuPrice: bigint;
-    cuPriceProposals: Array<bigint>;
-    lastUpdatedEpoch: Epoch;
-    nodes: Array<NodeRef>;
-    pendingNodes: Array<number>;
-    blsPublicKey: {
-        __kind: 'Set';
-        fields: readonly [BN254G2BLSPublicKey];
-    } | {
-        __kind: 'Unset';
-        fields: readonly [BN254G2BLSPublicKey, Array<boolean>];
-    };
-    bump: number;
-};
-type ClusterArgs = {
-    tdInfo: OptionOrNullable<NodeMetadataArgs>;
-    authority: OptionOrNullable<Address>;
-    clusterSize: number;
-    activation: ActivationArgs;
-    maxCapacity: number | bigint;
-    cuPrice: number | bigint;
-    cuPriceProposals: Array<number | bigint>;
-    lastUpdatedEpoch: EpochArgs;
-    nodes: Array<NodeRefArgs>;
-    pendingNodes: Array<number>;
-    blsPublicKey: {
-        __kind: 'Set';
-        fields: readonly [BN254G2BLSPublicKeyArgs];
-    } | {
-        __kind: 'Unset';
-        fields: readonly [BN254G2BLSPublicKeyArgs, Array<boolean>];
-    };
-    bump: number;
+    stakeAccount: Address;
+    stakeAccountId: number;
+    amount: number | bigint;
+    timestamp: number | bigint;
 };
-declare function getClusterEncoder(): Encoder<ClusterArgs>;
-declare function getClusterDecoder(): Decoder<Cluster>;
-declare function getClusterCodec(): Codec<ClusterArgs, Cluster>;
-declare function decodeCluster<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<Cluster, TAddress>;
-declare function decodeCluster<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<Cluster, TAddress>;
-declare function fetchCluster<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<Cluster, TAddress>>;
-declare function fetchMaybeCluster<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<Cluster, TAddress>>;
-declare function fetchAllCluster(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<Cluster>[]>;
-declare function fetchAllMaybeCluster(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<Cluster>[]>;
+declare function getUnstakedEventEncoder(): FixedSizeEncoder<UnstakedEventArgs>;
+declare function getUnstakedEventDecoder(): FixedSizeDecoder<UnstakedEvent>;
+declare function getUnstakedEventCodec(): FixedSizeCodec<UnstakedEventArgs, UnstakedEvent>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -1238,32 +1295,21 @@ declare function fetchAllMaybeCluster(rpc: Parameters<typeof fetchEncodedAccount
  * @see https://github.com/codama-idl/codama
  */
 
-declare const COMPUTATION_DEFINITION_ACCOUNT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getComputationDefinitionAccountDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type ComputationDefinitionAccount = {
-    discriminator: ReadonlyUint8Array;
-    finalizationAuthority: Option<Address>;
-    cuAmount: bigint;
-    definition: ComputationDefinitionMeta;
-    circuitSource: CircuitSource;
-    bump: number;
+type UpdateAuthorityChangedEvent = {
+    platformConfig: Address;
+    oldValue: Address;
+    newValue: Address;
+    timestamp: bigint;
 };
-type ComputationDefinitionAccountArgs = {
-    finalizationAuthority: OptionOrNullable<Address>;
-    cuAmount: number | bigint;
-    definition: ComputationDefinitionMetaArgs;
-    circuitSource: CircuitSourceArgs;
-    bump: number;
+type UpdateAuthorityChangedEventArgs = {
+    platformConfig: Address;
+    oldValue: Address;
+    newValue: Address;
+    timestamp: number | bigint;
 };
-declare function getComputationDefinitionAccountEncoder(): Encoder<ComputationDefinitionAccountArgs>;
-declare function getComputationDefinitionAccountDecoder(): Decoder<ComputationDefinitionAccount>;
-declare function getComputationDefinitionAccountCodec(): Codec<ComputationDefinitionAccountArgs, ComputationDefinitionAccount>;
-declare function decodeComputationDefinitionAccount<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<ComputationDefinitionAccount, TAddress>;
-declare function decodeComputationDefinitionAccount<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<ComputationDefinitionAccount, TAddress>;
-declare function fetchComputationDefinitionAccount<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<ComputationDefinitionAccount, TAddress>>;
-declare function fetchMaybeComputationDefinitionAccount<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<ComputationDefinitionAccount, TAddress>>;
-declare function fetchAllComputationDefinitionAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<ComputationDefinitionAccount>[]>;
-declare function fetchAllMaybeComputationDefinitionAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<ComputationDefinitionAccount>[]>;
+declare function getUpdateAuthorityChangedEventEncoder(): FixedSizeEncoder<UpdateAuthorityChangedEventArgs>;
+declare function getUpdateAuthorityChangedEventDecoder(): FixedSizeDecoder<UpdateAuthorityChangedEvent>;
+declare function getUpdateAuthorityChangedEventCodec(): FixedSizeCodec<UpdateAuthorityChangedEventArgs, UpdateAuthorityChangedEvent>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -1273,24 +1319,16 @@ declare function fetchAllMaybeComputationDefinitionAccount(rpc: Parameters<typeo
  * @see https://github.com/codama-idl/codama
  */
 
-declare const FEE_POOL_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getFeePoolDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type FeePool = {
-    discriminator: ReadonlyUint8Array;
-    bump: number;
-};
-type FeePoolArgs = {
-    bump: number;
+type UtilityPubkeys = {
+    x25519Pubkey: Array<number>;
+    ed25519VerifyingKey: Array<number>;
+    elgamalPubkey: Array<number>;
+    pubkeyValidityProof: Array<number>;
 };
-declare function getFeePoolEncoder(): FixedSizeEncoder<FeePoolArgs>;
-declare function getFeePoolDecoder(): FixedSizeDecoder<FeePool>;
-declare function getFeePoolCodec(): FixedSizeCodec<FeePoolArgs, FeePool>;
-declare function decodeFeePool<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<FeePool, TAddress>;
-declare function decodeFeePool<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<FeePool, TAddress>;
-declare function fetchFeePool<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<FeePool, TAddress>>;
-declare function fetchMaybeFeePool<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<FeePool, TAddress>>;
-declare function fetchAllFeePool(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<FeePool>[]>;
-declare function fetchAllMaybeFeePool(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<FeePool>[]>;
+type UtilityPubkeysArgs = UtilityPubkeys;
+declare function getUtilityPubkeysEncoder(): FixedSizeEncoder<UtilityPubkeysArgs>;
+declare function getUtilityPubkeysDecoder(): FixedSizeDecoder<UtilityPubkeys>;
+declare function getUtilityPubkeysCodec(): FixedSizeCodec<UtilityPubkeysArgs, UtilityPubkeys>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -1300,54 +1338,27 @@ declare function fetchAllMaybeFeePool(rpc: Parameters<typeof fetchEncodedAccount
  * @see https://github.com/codama-idl/codama
  */
 
-declare const M_X_E_ACCOUNT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getMXEAccountDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type MXEAccount = {
-    discriminator: ReadonlyUint8Array;
-    cluster: Option<number>;
-    keygenOffset: bigint;
-    keyRecoveryInitOffset: bigint;
-    mxeProgramId: Address;
-    authority: Option<Address>;
-    utilityPubkeys: {
-        __kind: 'Set';
-        fields: readonly [UtilityPubkeys];
-    } | {
-        __kind: 'Unset';
-        fields: readonly [UtilityPubkeys, Array<boolean>];
-    };
-    lutOffsetSlot: bigint;
-    computationDefinitions: Array<number>;
-    status: MxeStatus;
-    bump: number;
+type WinningOptionSetEvent = {
+    market: Address;
+    marketAuthority: Address;
+    option: Address;
+    optionId: bigint;
+    rewardPercentageBp: number;
+    winningOptionAllocation: number;
+    timestamp: bigint;
 };
-type MXEAccountArgs = {
-    cluster: OptionOrNullable<number>;
-    keygenOffset: number | bigint;
-    keyRecoveryInitOffset: number | bigint;
-    mxeProgramId: Address;
-    authority: OptionOrNullable<Address>;
-    utilityPubkeys: {
-        __kind: 'Set';
-        fields: readonly [UtilityPubkeysArgs];
-    } | {
-        __kind: 'Unset';
-        fields: readonly [UtilityPubkeysArgs, Array<boolean>];
-    };
-    lutOffsetSlot: number | bigint;
-    computationDefinitions: Array<number>;
-    status: MxeStatusArgs;
-    bump: number;
+type WinningOptionSetEventArgs = {
+    market: Address;
+    marketAuthority: Address;
+    option: Address;
+    optionId: number | bigint;
+    rewardPercentageBp: number;
+    winningOptionAllocation: number;
+    timestamp: number | bigint;
 };
-declare function getMXEAccountEncoder(): Encoder<MXEAccountArgs>;
-declare function getMXEAccountDecoder(): Decoder<MXEAccount>;
-declare function getMXEAccountCodec(): Codec<MXEAccountArgs, MXEAccount>;
-declare function decodeMXEAccount<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<MXEAccount, TAddress>;
-declare function decodeMXEAccount<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<MXEAccount, TAddress>;
-declare function fetchMXEAccount<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<MXEAccount, TAddress>>;
-declare function fetchMaybeMXEAccount<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<MXEAccount, TAddress>>;
-declare function fetchAllMXEAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<MXEAccount>[]>;
-declare function fetchAllMaybeMXEAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<MXEAccount>[]>;
+declare function getWinningOptionSetEventEncoder(): FixedSizeEncoder<WinningOptionSetEventArgs>;
+declare function getWinningOptionSetEventDecoder(): FixedSizeDecoder<WinningOptionSetEvent>;
+declare function getWinningOptionSetEventCodec(): FixedSizeCodec<WinningOptionSetEventArgs, WinningOptionSetEvent>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -1365,38 +1376,56 @@ type OpportunityMarket = {
     creator: Address;
     index: bigint;
     totalOptions: bigint;
-    openTimestamp: Option<bigint>;
-    timeToStake: bigint;
-    timeToReveal: bigint;
-    selectedOptions: Option<Array<WinningOption>>;
+    platform: Address;
+    stakeEndTimestamp: Option<bigint>;
+    resolvedAtTimestamp: Option<bigint>;
+    winningOptionAllocation: number;
     rewardAmount: bigint;
     marketAuthority: Address;
     revealPeriodAuthority: Address;
     mint: Address;
     earlinessCutoffSeconds: bigint;
-    unstakeDelaySeconds: bigint;
+    earlinessMultiplier: number;
+    allowUnstakingEarly: boolean;
     authorizedReaderPubkey: Array<number>;
-    allowClosingEarly: boolean;
-    paused: boolean;
+    stakingPaused: boolean;
+    feeRates: FeeRates;
+    collectedPlatformFees: bigint;
+    collectedCreatorFees: bigint;
+    creatorFeeClaimer: Address;
+    marketResolutionDeadlineSeconds: bigint;
+    minRevealPeriodSeconds: bigint;
+    maxRevealPeriodSeconds: bigint;
+    revealEnded: boolean;
+    minStakeAmount: bigint;
 };
 type OpportunityMarketArgs = {
     bump: number;
     creator: Address;
     index: number | bigint;
     totalOptions: number | bigint;
-    openTimestamp: OptionOrNullable<number | bigint>;
-    timeToStake: number | bigint;
-    timeToReveal: number | bigint;
-    selectedOptions: OptionOrNullable<Array<WinningOptionArgs>>;
+    platform: Address;
+    stakeEndTimestamp: OptionOrNullable<number | bigint>;
+    resolvedAtTimestamp: OptionOrNullable<number | bigint>;
+    winningOptionAllocation: number;
     rewardAmount: number | bigint;
     marketAuthority: Address;
     revealPeriodAuthority: Address;
     mint: Address;
     earlinessCutoffSeconds: number | bigint;
-    unstakeDelaySeconds: number | bigint;
+    earlinessMultiplier: number;
+    allowUnstakingEarly: boolean;
     authorizedReaderPubkey: Array<number>;
-    allowClosingEarly: boolean;
-    paused: boolean;
+    stakingPaused: boolean;
+    feeRates: FeeRatesArgs;
+    collectedPlatformFees: number | bigint;
+    collectedCreatorFees: number | bigint;
+    creatorFeeClaimer: Address;
+    marketResolutionDeadlineSeconds: number | bigint;
+    minRevealPeriodSeconds: number | bigint;
+    maxRevealPeriodSeconds: number | bigint;
+    revealEnded: boolean;
+    minStakeAmount: number | bigint;
 };
 declare function getOpportunityMarketEncoder(): Encoder<OpportunityMarketArgs>;
 declare function getOpportunityMarketDecoder(): Decoder<OpportunityMarket>;
@@ -1422,18 +1451,24 @@ type OpportunityMarketOption = {
     discriminator: ReadonlyUint8Array;
     bump: number;
     id: bigint;
+    creator: Address;
+    createdAt: bigint;
     totalStaked: bigint;
     totalScore: bigint;
+    rewardPercentageBp: Option<number>;
 };
 type OpportunityMarketOptionArgs = {
     bump: number;
     id: number | bigint;
+    creator: Address;
+    createdAt: number | bigint;
     totalStaked: number | bigint;
     totalScore: number | bigint;
+    rewardPercentageBp: OptionOrNullable<number>;
 };
-declare function getOpportunityMarketOptionEncoder(): FixedSizeEncoder<OpportunityMarketOptionArgs>;
-declare function getOpportunityMarketOptionDecoder(): FixedSizeDecoder<OpportunityMarketOption>;
-declare function getOpportunityMarketOptionCodec(): FixedSizeCodec<OpportunityMarketOptionArgs, OpportunityMarketOption>;
+declare function getOpportunityMarketOptionEncoder(): Encoder<OpportunityMarketOptionArgs>;
+declare function getOpportunityMarketOptionDecoder(): Decoder<OpportunityMarketOption>;
+declare function getOpportunityMarketOptionCodec(): Codec<OpportunityMarketOptionArgs, OpportunityMarketOption>;
 declare function decodeOpportunityMarketOption<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<OpportunityMarketOption, TAddress>;
 declare function decodeOpportunityMarketOption<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<OpportunityMarketOption, TAddress>;
 declare function fetchOpportunityMarketOption<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<OpportunityMarketOption, TAddress>>;
@@ -1476,6 +1511,49 @@ declare function fetchMaybeOpportunityMarketSponsor<TAddress extends string = st
 declare function fetchAllOpportunityMarketSponsor(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<OpportunityMarketSponsor>[]>;
 declare function fetchAllMaybeOpportunityMarketSponsor(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<OpportunityMarketSponsor>[]>;
 
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+declare const PLATFORM_CONFIG_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getPlatformConfigDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type PlatformConfig = {
+    discriminator: ReadonlyUint8Array;
+    bump: number;
+    name: string;
+    updateAuthority: Address;
+    feeClaimAuthority: Address;
+    feeRates: FeeRates;
+    marketResolutionDeadlineSeconds: bigint;
+    minTimeToStakeSeconds: bigint;
+    minRevealPeriodSeconds: bigint;
+    maxRevealPeriodSeconds: bigint;
+};
+type PlatformConfigArgs = {
+    bump: number;
+    name: string;
+    updateAuthority: Address;
+    feeClaimAuthority: Address;
+    feeRates: FeeRatesArgs;
+    marketResolutionDeadlineSeconds: number | bigint;
+    minTimeToStakeSeconds: number | bigint;
+    minRevealPeriodSeconds: number | bigint;
+    maxRevealPeriodSeconds: number | bigint;
+};
+declare function getPlatformConfigEncoder(): Encoder<PlatformConfigArgs>;
+declare function getPlatformConfigDecoder(): Decoder<PlatformConfig>;
+declare function getPlatformConfigCodec(): Codec<PlatformConfigArgs, PlatformConfig>;
+declare function decodePlatformConfig<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<PlatformConfig, TAddress>;
+declare function decodePlatformConfig<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<PlatformConfig, TAddress>;
+declare function fetchPlatformConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<PlatformConfig, TAddress>>;
+declare function fetchMaybePlatformConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<PlatformConfig, TAddress>>;
+declare function fetchAllPlatformConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<PlatformConfig>[]>;
+declare function fetchAllMaybePlatformConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<PlatformConfig>[]>;
+
 /**
  * This code was AUTOGENERATED using the Codama library.
  * Please DO NOT EDIT THIS FILE, instead use visitors
@@ -1499,16 +1577,13 @@ type StakeAccount = {
     stakedAtTimestamp: Option<bigint>;
     unstakedAtTimestamp: Option<bigint>;
     amount: bigint;
-    fee: bigint;
+    collectedFees: CollectedFees;
     revealedOption: Option<bigint>;
     score: Option<bigint>;
-    totalIncremented: boolean;
-    unstakeableAtTimestamp: Option<bigint>;
-    locked: boolean;
-    stakeReclaimed: boolean;
-    pendingStake: boolean;
-    pendingReveal: boolean;
+    unstaked: boolean;
     id: number;
+    pendingStakeComputation: Option<Address>;
+    pendingReveal: boolean;
 };
 type StakeAccountArgs = {
     encryptedOption: Array<number>;
@@ -1522,16 +1597,13 @@ type StakeAccountArgs = {
     stakedAtTimestamp: OptionOrNullable<number | bigint>;
     unstakedAtTimestamp: OptionOrNullable<number | bigint>;
     amount: number | bigint;
-    fee: number | bigint;
+    collectedFees: CollectedFeesArgs;
     revealedOption: OptionOrNullable<number | bigint>;
     score: OptionOrNullable<number | bigint>;
-    totalIncremented: boolean;
-    unstakeableAtTimestamp: OptionOrNullable<number | bigint>;
-    locked: boolean;
-    stakeReclaimed: boolean;
-    pendingStake: boolean;
-    pendingReveal: boolean;
+    unstaked: boolean;
     id: number;
+    pendingStakeComputation: OptionOrNullable<Address>;
+    pendingReveal: boolean;
 };
 declare function getStakeAccountEncoder(): Encoder<StakeAccountArgs>;
 declare function getStakeAccountDecoder(): Decoder<StakeAccount>;
@@ -1543,74 +1615,6 @@ declare function fetchMaybeStakeAccount<TAddress extends string = string>(rpc: P
 declare function fetchAllStakeAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<StakeAccount>[]>;
 declare function fetchAllMaybeStakeAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<StakeAccount>[]>;
 
-/**
- * This code was AUTOGENERATED using the Codama library.
- * Please DO NOT EDIT THIS FILE, instead use visitors
- * to add features, then rerun Codama to update it.
- *
- * @see https://github.com/codama-idl/codama
- */
-
-declare const TIMELOCKED_ACCOUNT_CHANGE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getTimelockedAccountChangeDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type TimelockedAccountChange = {
-    discriminator: ReadonlyUint8Array;
-    bump: number;
-    currentValue: Address;
-    proposedValue: Address;
-    executeAfter: bigint;
-};
-type TimelockedAccountChangeArgs = {
-    bump: number;
-    currentValue: Address;
-    proposedValue: Address;
-    executeAfter: number | bigint;
-};
-declare function getTimelockedAccountChangeEncoder(): FixedSizeEncoder<TimelockedAccountChangeArgs>;
-declare function getTimelockedAccountChangeDecoder(): FixedSizeDecoder<TimelockedAccountChange>;
-declare function getTimelockedAccountChangeCodec(): FixedSizeCodec<TimelockedAccountChangeArgs, TimelockedAccountChange>;
-declare function decodeTimelockedAccountChange<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<TimelockedAccountChange, TAddress>;
-declare function decodeTimelockedAccountChange<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<TimelockedAccountChange, TAddress>;
-declare function fetchTimelockedAccountChange<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<TimelockedAccountChange, TAddress>>;
-declare function fetchMaybeTimelockedAccountChange<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<TimelockedAccountChange, TAddress>>;
-declare function fetchAllTimelockedAccountChange(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<TimelockedAccountChange>[]>;
-declare function fetchAllMaybeTimelockedAccountChange(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<TimelockedAccountChange>[]>;
-
-/**
- * This code was AUTOGENERATED using the Codama library.
- * Please DO NOT EDIT THIS FILE, instead use visitors
- * to add features, then rerun Codama to update it.
- *
- * @see https://github.com/codama-idl/codama
- */
-
-declare const TOKEN_VAULT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getTokenVaultDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type TokenVault = {
-    discriminator: ReadonlyUint8Array;
-    bump: number;
-    mint: Address;
-    collectedFees: bigint;
-    /** Reserved for future use */
-    reserved: Array<number>;
-};
-type TokenVaultArgs = {
-    bump: number;
-    mint: Address;
-    collectedFees: number | bigint;
-    /** Reserved for future use */
-    reserved: Array<number>;
-};
-declare function getTokenVaultEncoder(): FixedSizeEncoder<TokenVaultArgs>;
-declare function getTokenVaultDecoder(): FixedSizeDecoder<TokenVault>;
-declare function getTokenVaultCodec(): FixedSizeCodec<TokenVaultArgs, TokenVault>;
-declare function decodeTokenVault<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<TokenVault, TAddress>;
-declare function decodeTokenVault<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<TokenVault, TAddress>;
-declare function fetchTokenVault<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<TokenVault, TAddress>>;
-declare function fetchMaybeTokenVault<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<TokenVault, TAddress>>;
-declare function fetchAllTokenVault(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<TokenVault>[]>;
-declare function fetchAllMaybeTokenVault(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<TokenVault>[]>;
-
 /**
  * This code was AUTOGENERATED using the Codama library.
  * Please DO NOT EDIT THIS FILE, instead use visitors
@@ -1621,24 +1625,24 @@ declare function fetchAllMaybeTokenVault(rpc: Parameters<typeof fetchEncodedAcco
 
 /** AbortedComputation: Computation aborted */
 declare const OPPORTUNITY_MARKET_ERROR__ABORTED_COMPUTATION = 6000;
-/** ClusterNotSet: Cluster not set */
-declare const OPPORTUNITY_MARKET_ERROR__CLUSTER_NOT_SET = 6001;
 /** Unauthorized: Unauthorized */
-declare const OPPORTUNITY_MARKET_ERROR__UNAUTHORIZED = 6002;
+declare const OPPORTUNITY_MARKET_ERROR__UNAUTHORIZED = 6001;
 /** InsufficientBalance: Insufficient balance */
-declare const OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_BALANCE = 6003;
+declare const OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_BALANCE = 6002;
 /** InsufficientRewardFunding: Insufficient reward funding */
-declare const OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_REWARD_FUNDING = 6004;
-/** InvalidTimestamp: Timestamp must be in the future */
-declare const OPPORTUNITY_MARKET_ERROR__INVALID_TIMESTAMP = 6005;
+declare const OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_REWARD_FUNDING = 6003;
+/** InvalidParameters: Invalid parameters */
+declare const OPPORTUNITY_MARKET_ERROR__INVALID_PARAMETERS = 6004;
 /** MarketAlreadyOpen: Market is already open */
-declare const OPPORTUNITY_MARKET_ERROR__MARKET_ALREADY_OPEN = 6006;
+declare const OPPORTUNITY_MARKET_ERROR__MARKET_ALREADY_OPEN = 6005;
 /** InvalidOptionId: Invalid option ID */
-declare const OPPORTUNITY_MARKET_ERROR__INVALID_OPTION_ID = 6007;
+declare const OPPORTUNITY_MARKET_ERROR__INVALID_OPTION_ID = 6006;
 /** MarketNotOpen: Market is not open */
-declare const OPPORTUNITY_MARKET_ERROR__MARKET_NOT_OPEN = 6008;
-/** StakingNotActive: Staking period is not active */
-declare const OPPORTUNITY_MARKET_ERROR__STAKING_NOT_ACTIVE = 6009;
+declare const OPPORTUNITY_MARKET_ERROR__MARKET_NOT_OPEN = 6007;
+/** TimeWindowMismatch: Operation called outside its permitted time window */
+declare const OPPORTUNITY_MARKET_ERROR__TIME_WINDOW_MISMATCH = 6008;
+/** NoStake: Stake account has no recorded stake */
+declare const OPPORTUNITY_MARKET_ERROR__NO_STAKE = 6009;
 /** WinnerAlreadySelected: Market winner already selected */
 declare const OPPORTUNITY_MARKET_ERROR__WINNER_ALREADY_SELECTED = 6010;
 /** AlreadyRevealed: Stake already revealed */
@@ -1667,29 +1671,31 @@ declare const OPPORTUNITY_MARKET_ERROR__ADD_OPTION_STAKE_FAILED = 6021;
 declare const OPPORTUNITY_MARKET_ERROR__LOCKED = 6022;
 /** InvalidAccountState: Invalid account state */
 declare const OPPORTUNITY_MARKET_ERROR__INVALID_ACCOUNT_STATE = 6023;
-/** UnstakeDelayNotMet: Unstake delay period has not passed yet */
-declare const OPPORTUNITY_MARKET_ERROR__UNSTAKE_DELAY_NOT_MET = 6024;
-/** UnstakeNotInitiated: Unstake has not been initiated */
-declare const OPPORTUNITY_MARKET_ERROR__UNSTAKE_NOT_INITIATED = 6025;
-/** ClosingEarlyNotAllowed: Market cannot be closed before stake period ends */
-declare const OPPORTUNITY_MARKET_ERROR__CLOSING_EARLY_NOT_ALLOWED = 6026;
 /** NoFeesToClaim: No fees to claim */
-declare const OPPORTUNITY_MARKET_ERROR__NO_FEES_TO_CLAIM = 6027;
-/** InvalidWinningOptionsInput: Invalid winning options input */
-declare const OPPORTUNITY_MARKET_ERROR__INVALID_WINNING_OPTIONS_INPUT = 6028;
+declare const OPPORTUNITY_MARKET_ERROR__NO_FEES_TO_CLAIM = 6024;
 /** StakeNotStuck: Stake account is not in a stuck or failed state */
-declare const OPPORTUNITY_MARKET_ERROR__STAKE_NOT_STUCK = 6029;
-/** ProtocolFeeTooHigh: Protocol fee exceeds maximum 500 bp */
-declare const OPPORTUNITY_MARKET_ERROR__PROTOCOL_FEE_TOO_HIGH = 6030;
+declare const OPPORTUNITY_MARKET_ERROR__STAKE_NOT_STUCK = 6025;
 /** MarketPaused: Market staking is currently paused */
-declare const OPPORTUNITY_MARKET_ERROR__MARKET_PAUSED = 6031;
+declare const OPPORTUNITY_MARKET_ERROR__MARKET_PAUSED = 6026;
 /** MarketNotPaused: Market is not paused */
-declare const OPPORTUNITY_MARKET_ERROR__MARKET_NOT_PAUSED = 6032;
-/** EarlinessCutoffTooLarge: Earliness cutoff exceeds staking period */
-declare const OPPORTUNITY_MARKET_ERROR__EARLINESS_CUTOFF_TOO_LARGE = 6033;
-/** TimelockNotElapsed: Timelock period has not elapsed yet */
-declare const OPPORTUNITY_MARKET_ERROR__TIMELOCK_NOT_ELAPSED = 6034;
-type OpportunityMarketError = typeof OPPORTUNITY_MARKET_ERROR__ABORTED_COMPUTATION | typeof OPPORTUNITY_MARKET_ERROR__ADD_OPTION_STAKE_FAILED | typeof OPPORTUNITY_MARKET_ERROR__ALREADY_REVEALED | typeof OPPORTUNITY_MARKET_ERROR__ALREADY_STAKED | typeof OPPORTUNITY_MARKET_ERROR__ALREADY_UNSTAKED | typeof OPPORTUNITY_MARKET_ERROR__CLOSING_EARLY_NOT_ALLOWED | typeof OPPORTUNITY_MARKET_ERROR__CLUSTER_NOT_SET | typeof OPPORTUNITY_MARKET_ERROR__DEPOSIT_BELOW_MINIMUM | typeof OPPORTUNITY_MARKET_ERROR__EARLINESS_CUTOFF_TOO_LARGE | typeof OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_BALANCE | typeof OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_REWARD_FUNDING | typeof OPPORTUNITY_MARKET_ERROR__INVALID_ACCOUNT_STATE | typeof OPPORTUNITY_MARKET_ERROR__INVALID_MINT | typeof OPPORTUNITY_MARKET_ERROR__INVALID_OPTION_ID | typeof OPPORTUNITY_MARKET_ERROR__INVALID_TIMESTAMP | typeof OPPORTUNITY_MARKET_ERROR__INVALID_WINNING_OPTIONS_INPUT | typeof OPPORTUNITY_MARKET_ERROR__LOCKED | typeof OPPORTUNITY_MARKET_ERROR__MARKET_ALREADY_OPEN | typeof OPPORTUNITY_MARKET_ERROR__MARKET_NOT_OPEN | typeof OPPORTUNITY_MARKET_ERROR__MARKET_NOT_PAUSED | typeof OPPORTUNITY_MARKET_ERROR__MARKET_NOT_RESOLVED | typeof OPPORTUNITY_MARKET_ERROR__MARKET_PAUSED | typeof OPPORTUNITY_MARKET_ERROR__NO_FEES_TO_CLAIM | typeof OPPORTUNITY_MARKET_ERROR__NOT_REVEALED | typeof OPPORTUNITY_MARKET_ERROR__OVERFLOW | typeof OPPORTUNITY_MARKET_ERROR__PROTOCOL_FEE_TOO_HIGH | typeof OPPORTUNITY_MARKET_ERROR__REVEAL_PERIOD_ENDED | typeof OPPORTUNITY_MARKET_ERROR__STAKE_NOT_STUCK | typeof OPPORTUNITY_MARKET_ERROR__STAKING_NOT_ACTIVE | typeof OPPORTUNITY_MARKET_ERROR__TALLY_ALREADY_INCREMENTED | typeof OPPORTUNITY_MARKET_ERROR__TIMELOCK_NOT_ELAPSED | typeof OPPORTUNITY_MARKET_ERROR__UNAUTHORIZED | typeof OPPORTUNITY_MARKET_ERROR__UNSTAKE_DELAY_NOT_MET | typeof OPPORTUNITY_MARKET_ERROR__UNSTAKE_NOT_INITIATED | typeof OPPORTUNITY_MARKET_ERROR__WINNER_ALREADY_SELECTED;
+declare const OPPORTUNITY_MARKET_ERROR__MARKET_NOT_PAUSED = 6027;
+/** StakeBelowMinimum: Stake amount is below the market minimum */
+declare const OPPORTUNITY_MARKET_ERROR__STAKE_BELOW_MINIMUM = 6028;
+/** SelectOptionsDeadlinePassed: Deadline for selecting winning options has passed */
+declare const OPPORTUNITY_MARKET_ERROR__SELECT_OPTIONS_DEADLINE_PASSED = 6029;
+/** InvalidFeeRates: Invalid fee rates */
+declare const OPPORTUNITY_MARKET_ERROR__INVALID_FEE_RATES = 6030;
+/** OptionStillNeeded: Option still needed */
+declare const OPPORTUNITY_MARKET_ERROR__OPTION_STILL_NEEDED = 6031;
+/** CreatorMismatch: Creator mismatch */
+declare const OPPORTUNITY_MARKET_ERROR__CREATOR_MISMATCH = 6032;
+/** RevealPeriodNotOver: Reveal period not over */
+declare const OPPORTUNITY_MARKET_ERROR__REVEAL_PERIOD_NOT_OVER = 6033;
+/** NoRewardToClaim: No reward to claim */
+declare const OPPORTUNITY_MARKET_ERROR__NO_REWARD_TO_CLAIM = 6034;
+/** RewardAlreadyClaimed: Reward already claimed */
+declare const OPPORTUNITY_MARKET_ERROR__REWARD_ALREADY_CLAIMED = 6035;
+type OpportunityMarketError = typeof OPPORTUNITY_MARKET_ERROR__ABORTED_COMPUTATION | typeof OPPORTUNITY_MARKET_ERROR__ADD_OPTION_STAKE_FAILED | typeof OPPORTUNITY_MARKET_ERROR__ALREADY_REVEALED | typeof OPPORTUNITY_MARKET_ERROR__ALREADY_STAKED | typeof OPPORTUNITY_MARKET_ERROR__ALREADY_UNSTAKED | typeof OPPORTUNITY_MARKET_ERROR__CREATOR_MISMATCH | typeof OPPORTUNITY_MARKET_ERROR__DEPOSIT_BELOW_MINIMUM | typeof OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_BALANCE | typeof OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_REWARD_FUNDING | typeof OPPORTUNITY_MARKET_ERROR__INVALID_ACCOUNT_STATE | typeof OPPORTUNITY_MARKET_ERROR__INVALID_FEE_RATES | typeof OPPORTUNITY_MARKET_ERROR__INVALID_MINT | typeof OPPORTUNITY_MARKET_ERROR__INVALID_OPTION_ID | typeof OPPORTUNITY_MARKET_ERROR__INVALID_PARAMETERS | typeof OPPORTUNITY_MARKET_ERROR__LOCKED | typeof OPPORTUNITY_MARKET_ERROR__MARKET_ALREADY_OPEN | typeof OPPORTUNITY_MARKET_ERROR__MARKET_NOT_OPEN | typeof OPPORTUNITY_MARKET_ERROR__MARKET_NOT_PAUSED | typeof OPPORTUNITY_MARKET_ERROR__MARKET_NOT_RESOLVED | typeof OPPORTUNITY_MARKET_ERROR__MARKET_PAUSED | typeof OPPORTUNITY_MARKET_ERROR__NO_FEES_TO_CLAIM | typeof OPPORTUNITY_MARKET_ERROR__NO_REWARD_TO_CLAIM | typeof OPPORTUNITY_MARKET_ERROR__NO_STAKE | typeof OPPORTUNITY_MARKET_ERROR__NOT_REVEALED | typeof OPPORTUNITY_MARKET_ERROR__OPTION_STILL_NEEDED | typeof OPPORTUNITY_MARKET_ERROR__OVERFLOW | typeof OPPORTUNITY_MARKET_ERROR__REVEAL_PERIOD_ENDED | typeof OPPORTUNITY_MARKET_ERROR__REVEAL_PERIOD_NOT_OVER | typeof OPPORTUNITY_MARKET_ERROR__REWARD_ALREADY_CLAIMED | typeof OPPORTUNITY_MARKET_ERROR__SELECT_OPTIONS_DEADLINE_PASSED | typeof OPPORTUNITY_MARKET_ERROR__STAKE_BELOW_MINIMUM | typeof OPPORTUNITY_MARKET_ERROR__STAKE_NOT_STUCK | typeof OPPORTUNITY_MARKET_ERROR__TALLY_ALREADY_INCREMENTED | typeof OPPORTUNITY_MARKET_ERROR__TIME_WINDOW_MISMATCH | typeof OPPORTUNITY_MARKET_ERROR__UNAUTHORIZED | typeof OPPORTUNITY_MARKET_ERROR__WINNER_ALREADY_SELECTED;
 declare function getOpportunityMarketErrorMessage(code: OpportunityMarketError): string;
 declare function isOpportunityMarketError<TProgramErrorCode extends OpportunityMarketError>(error: unknown, transactionMessage: {
     instructions: Record<number, {
@@ -1711,19 +1717,13 @@ declare function isOpportunityMarketError<TProgramErrorCode extends OpportunityM
 
 declare const OPPORTUNITY_MARKET_PROGRAM_ADDRESS: Address<"B3NCHsGBkdZrPYPJY2rjg4UwmyRotMmFWhxa5hMHwLeg">;
 declare enum OpportunityMarketAccount {
-    ArciumSignerAccount = 0,
-    CentralState = 1,
-    ClockAccount = 2,
-    Cluster = 3,
-    ComputationDefinitionAccount = 4,
-    FeePool = 5,
-    MXEAccount = 6,
-    OpportunityMarket = 7,
-    OpportunityMarketOption = 8,
-    OpportunityMarketSponsor = 9,
-    StakeAccount = 10,
-    TimelockedAccountChange = 11,
-    TokenVault = 12
+    AllowedMint = 0,
+    ArciumSignerAccount = 1,
+    OpportunityMarket = 2,
+    OpportunityMarketOption = 3,
+    OpportunityMarketSponsor = 4,
+    PlatformConfig = 5,
+    StakeAccount = 6
 }
 declare function identifyOpportunityMarketAccount(account: {
     data: ReadonlyUint8Array;
@@ -1731,36 +1731,33 @@ declare function identifyOpportunityMarketAccount(account: {
 declare enum OpportunityMarketInstruction {
     AddMarketOption = 0,
     AddReward = 1,
-    CancelFeeClaimerChange = 2,
-    CancelUpdateAuthorityChange = 3,
-    ClaimFees = 4,
+    ClaimCreatorFees = 2,
+    ClaimFees = 3,
+    CloseOptionAccount = 4,
     CloseStakeAccount = 5,
     CloseStuckStakeAccount = 6,
     CreateMarket = 7,
-    DoUnstakeEarly = 8,
-    EndRevealPeriod = 9,
-    FinalizeNewFeeClaimer = 10,
-    FinalizeNewUpdateAuthority = 11,
-    IncrementOptionTally = 12,
-    InitCentralState = 13,
-    InitStakeAccount = 14,
-    InitTokenVault = 15,
-    OpenMarket = 16,
-    PauseMarket = 17,
-    ProposeNewFeeClaimer = 18,
-    ProposeNewUpdateAuthority = 19,
-    ReclaimStake = 20,
-    ResumeMarket = 21,
-    RevealStake = 22,
-    RevealStakeCallback = 23,
-    RevealStakeCompDef = 24,
-    SelectWinningOptions = 25,
-    Stake = 26,
-    StakeCallback = 27,
-    StakeCompDef = 28,
-    UnstakeEarly = 29,
-    UpdateCentralState = 30,
-    WithdrawReward = 31
+    EndRevealPeriod = 8,
+    FinalizeRevealStake = 9,
+    InitAllowedMint = 10,
+    InitPlatformConfig = 11,
+    InitStakeAccount = 12,
+    OpenMarket = 13,
+    PauseStaking = 14,
+    ResolveMarket = 15,
+    ResumeStaking = 16,
+    RevealStake = 17,
+    RevealStakeCallback = 18,
+    RevealStakeCompDef = 19,
+    SetFeeClaimAuthority = 20,
+    SetUpdateAuthority = 21,
+    SetWinningOption = 22,
+    Stake = 23,
+    StakeCallback = 24,
+    StakeCompDef = 25,
+    Unstake = 26,
+    UpdatePlatformConfig = 27,
+    WithdrawReward = 28
 }
 declare function identifyOpportunityMarketInstruction(instruction: {
     data: ReadonlyUint8Array;
@@ -1770,64 +1767,58 @@ type ParsedOpportunityMarketInstruction<TProgram extends string = 'B3NCHsGBkdZrP
 } & ParsedAddMarketOptionInstruction<TProgram>) | ({
     instructionType: OpportunityMarketInstruction.AddReward;
 } & ParsedAddRewardInstruction<TProgram>) | ({
-    instructionType: OpportunityMarketInstruction.CancelFeeClaimerChange;
-} & ParsedCancelFeeClaimerChangeInstruction<TProgram>) | ({
-    instructionType: OpportunityMarketInstruction.CancelUpdateAuthorityChange;
-} & ParsedCancelUpdateAuthorityChangeInstruction<TProgram>) | ({
+    instructionType: OpportunityMarketInstruction.ClaimCreatorFees;
+} & ParsedClaimCreatorFeesInstruction<TProgram>) | ({
     instructionType: OpportunityMarketInstruction.ClaimFees;
 } & ParsedClaimFeesInstruction<TProgram>) | ({
+    instructionType: OpportunityMarketInstruction.CloseOptionAccount;
+} & ParsedCloseOptionAccountInstruction<TProgram>) | ({
     instructionType: OpportunityMarketInstruction.CloseStakeAccount;
 } & ParsedCloseStakeAccountInstruction<TProgram>) | ({
     instructionType: OpportunityMarketInstruction.CloseStuckStakeAccount;
 } & ParsedCloseStuckStakeAccountInstruction<TProgram>) | ({
     instructionType: OpportunityMarketInstruction.CreateMarket;
 } & ParsedCreateMarketInstruction<TProgram>) | ({
-    instructionType: OpportunityMarketInstruction.DoUnstakeEarly;
-} & ParsedDoUnstakeEarlyInstruction<TProgram>) | ({
     instructionType: OpportunityMarketInstruction.EndRevealPeriod;
 } & ParsedEndRevealPeriodInstruction<TProgram>) | ({
-    instructionType: OpportunityMarketInstruction.FinalizeNewFeeClaimer;
-} & ParsedFinalizeNewFeeClaimerInstruction<TProgram>) | ({
-    instructionType: OpportunityMarketInstruction.FinalizeNewUpdateAuthority;
-} & ParsedFinalizeNewUpdateAuthorityInstruction<TProgram>) | ({
-    instructionType: OpportunityMarketInstruction.IncrementOptionTally;
-} & ParsedIncrementOptionTallyInstruction<TProgram>) | ({
-    instructionType: OpportunityMarketInstruction.InitCentralState;
-} & ParsedInitCentralStateInstruction<TProgram>) | ({
+    instructionType: OpportunityMarketInstruction.FinalizeRevealStake;
+} & ParsedFinalizeRevealStakeInstruction<TProgram>) | ({
+    instructionType: OpportunityMarketInstruction.InitAllowedMint;
+} & ParsedInitAllowedMintInstruction<TProgram>) | ({
+    instructionType: OpportunityMarketInstruction.InitPlatformConfig;
+} & ParsedInitPlatformConfigInstruction<TProgram>) | ({
     instructionType: OpportunityMarketInstruction.InitStakeAccount;
 } & ParsedInitStakeAccountInstruction<TProgram>) | ({
-    instructionType: OpportunityMarketInstruction.InitTokenVault;
-} & ParsedInitTokenVaultInstruction<TProgram>) | ({
     instructionType: OpportunityMarketInstruction.OpenMarket;
 } & ParsedOpenMarketInstruction<TProgram>) | ({
-    instructionType: OpportunityMarketInstruction.PauseMarket;
-} & ParsedPauseMarketInstruction<TProgram>) | ({
-    instructionType: OpportunityMarketInstruction.ProposeNewFeeClaimer;
-} & ParsedProposeNewFeeClaimerInstruction<TProgram>) | ({
-    instructionType: OpportunityMarketInstruction.ProposeNewUpdateAuthority;
-} & ParsedProposeNewUpdateAuthorityInstruction<TProgram>) | ({
-    instructionType: OpportunityMarketInstruction.ReclaimStake;
-} & ParsedReclaimStakeInstruction<TProgram>) | ({
-    instructionType: OpportunityMarketInstruction.ResumeMarket;
-} & ParsedResumeMarketInstruction<TProgram>) | ({
+    instructionType: OpportunityMarketInstruction.PauseStaking;
+} & ParsedPauseStakingInstruction<TProgram>) | ({
+    instructionType: OpportunityMarketInstruction.ResolveMarket;
+} & ParsedResolveMarketInstruction<TProgram>) | ({
+    instructionType: OpportunityMarketInstruction.ResumeStaking;
+} & ParsedResumeStakingInstruction<TProgram>) | ({
     instructionType: OpportunityMarketInstruction.RevealStake;
 } & ParsedRevealStakeInstruction<TProgram>) | ({
     instructionType: OpportunityMarketInstruction.RevealStakeCallback;
 } & ParsedRevealStakeCallbackInstruction<TProgram>) | ({
     instructionType: OpportunityMarketInstruction.RevealStakeCompDef;
 } & ParsedRevealStakeCompDefInstruction<TProgram>) | ({
-    instructionType: OpportunityMarketInstruction.SelectWinningOptions;
-} & ParsedSelectWinningOptionsInstruction<TProgram>) | ({
+    instructionType: OpportunityMarketInstruction.SetFeeClaimAuthority;
+} & ParsedSetFeeClaimAuthorityInstruction<TProgram>) | ({
+    instructionType: OpportunityMarketInstruction.SetUpdateAuthority;
+} & ParsedSetUpdateAuthorityInstruction<TProgram>) | ({
+    instructionType: OpportunityMarketInstruction.SetWinningOption;
+} & ParsedSetWinningOptionInstruction<TProgram>) | ({
     instructionType: OpportunityMarketInstruction.Stake;
 } & ParsedStakeInstruction<TProgram>) | ({
     instructionType: OpportunityMarketInstruction.StakeCallback;
 } & ParsedStakeCallbackInstruction<TProgram>) | ({
     instructionType: OpportunityMarketInstruction.StakeCompDef;
 } & ParsedStakeCompDefInstruction<TProgram>) | ({
-    instructionType: OpportunityMarketInstruction.UnstakeEarly;
-} & ParsedUnstakeEarlyInstruction<TProgram>) | ({
-    instructionType: OpportunityMarketInstruction.UpdateCentralState;
-} & ParsedUpdateCentralStateInstruction<TProgram>) | ({
+    instructionType: OpportunityMarketInstruction.Unstake;
+} & ParsedUnstakeInstruction<TProgram>) | ({
+    instructionType: OpportunityMarketInstruction.UpdatePlatformConfig;
+} & ParsedUpdatePlatformConfigInstruction<TProgram>) | ({
     instructionType: OpportunityMarketInstruction.WithdrawReward;
 } & ParsedWithdrawRewardInstruction<TProgram>);
 
@@ -1841,8 +1832,8 @@ type ParsedOpportunityMarketInstruction<TProgram extends string = 'B3NCHsGBkdZrP
 
 declare const ADD_MARKET_OPTION_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
 declare function getAddMarketOptionDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type AddMarketOptionInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountCreator extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountOption extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
-    TAccountCreator extends string ? WritableSignerAccount<TAccountCreator> & AccountSignerMeta<TAccountCreator> : TAccountCreator,
+type AddMarketOptionInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountOption extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountSigner extends string ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
     TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
     TAccountOption extends string ? WritableAccount<TAccountOption> : TAccountOption,
     TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
@@ -1858,30 +1849,30 @@ type AddMarketOptionInstructionDataArgs = {
 declare function getAddMarketOptionInstructionDataEncoder(): FixedSizeEncoder<AddMarketOptionInstructionDataArgs>;
 declare function getAddMarketOptionInstructionDataDecoder(): FixedSizeDecoder<AddMarketOptionInstructionData>;
 declare function getAddMarketOptionInstructionDataCodec(): FixedSizeCodec<AddMarketOptionInstructionDataArgs, AddMarketOptionInstructionData>;
-type AddMarketOptionAsyncInput<TAccountCreator extends string = string, TAccountMarket extends string = string, TAccountOption extends string = string, TAccountSystemProgram extends string = string> = {
-    creator: TransactionSigner<TAccountCreator>;
+type AddMarketOptionAsyncInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountOption extends string = string, TAccountSystemProgram extends string = string> = {
+    signer: TransactionSigner<TAccountSigner>;
     market: Address<TAccountMarket>;
     option?: Address<TAccountOption>;
     systemProgram?: Address<TAccountSystemProgram>;
     optionId: AddMarketOptionInstructionDataArgs['optionId'];
 };
-declare function getAddMarketOptionInstructionAsync<TAccountCreator extends string, TAccountMarket extends string, TAccountOption extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: AddMarketOptionAsyncInput<TAccountCreator, TAccountMarket, TAccountOption, TAccountSystemProgram>, config?: {
+declare function getAddMarketOptionInstructionAsync<TAccountSigner extends string, TAccountMarket extends string, TAccountOption extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: AddMarketOptionAsyncInput<TAccountSigner, TAccountMarket, TAccountOption, TAccountSystemProgram>, config?: {
     programAddress?: TProgramAddress;
-}): Promise<AddMarketOptionInstruction<TProgramAddress, TAccountCreator, TAccountMarket, TAccountOption, TAccountSystemProgram>>;
-type AddMarketOptionInput<TAccountCreator extends string = string, TAccountMarket extends string = string, TAccountOption extends string = string, TAccountSystemProgram extends string = string> = {
-    creator: TransactionSigner<TAccountCreator>;
+}): Promise<AddMarketOptionInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountOption, TAccountSystemProgram>>;
+type AddMarketOptionInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountOption extends string = string, TAccountSystemProgram extends string = string> = {
+    signer: TransactionSigner<TAccountSigner>;
     market: Address<TAccountMarket>;
     option: Address<TAccountOption>;
     systemProgram?: Address<TAccountSystemProgram>;
     optionId: AddMarketOptionInstructionDataArgs['optionId'];
 };
-declare function getAddMarketOptionInstruction<TAccountCreator extends string, TAccountMarket extends string, TAccountOption extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: AddMarketOptionInput<TAccountCreator, TAccountMarket, TAccountOption, TAccountSystemProgram>, config?: {
+declare function getAddMarketOptionInstruction<TAccountSigner extends string, TAccountMarket extends string, TAccountOption extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: AddMarketOptionInput<TAccountSigner, TAccountMarket, TAccountOption, TAccountSystemProgram>, config?: {
     programAddress?: TProgramAddress;
-}): AddMarketOptionInstruction<TProgramAddress, TAccountCreator, TAccountMarket, TAccountOption, TAccountSystemProgram>;
+}): AddMarketOptionInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountOption, TAccountSystemProgram>;
 type ParsedAddMarketOptionInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
-        creator: TAccountMetas[0];
+        signer: TAccountMetas[0];
         market: TAccountMetas[1];
         option: TAccountMetas[2];
         systemProgram: TAccountMetas[3];
@@ -1929,7 +1920,7 @@ type AddRewardAsyncInput<TAccountSponsor extends string = string, TAccountMarket
     sponsorAccount?: Address<TAccountSponsorAccount>;
     tokenMint: Address<TAccountTokenMint>;
     sponsorTokenAccount: Address<TAccountSponsorTokenAccount>;
-    /** Market's ATA holding reward tokens */
+    /** Market-owned ATA holding all program-held tokens for this market. */
     marketTokenAta?: Address<TAccountMarketTokenAta>;
     tokenProgram: Address<TAccountTokenProgram>;
     systemProgram?: Address<TAccountSystemProgram>;
@@ -1945,7 +1936,7 @@ type AddRewardInput<TAccountSponsor extends string = string, TAccountMarket exte
     sponsorAccount: Address<TAccountSponsorAccount>;
     tokenMint: Address<TAccountTokenMint>;
     sponsorTokenAccount: Address<TAccountSponsorTokenAccount>;
-    /** Market's ATA holding reward tokens */
+    /** Market-owned ATA holding all program-held tokens for this market. */
     marketTokenAta: Address<TAccountMarketTokenAta>;
     tokenProgram: Address<TAccountTokenProgram>;
     systemProgram?: Address<TAccountSystemProgram>;
@@ -1963,7 +1954,7 @@ type ParsedAddRewardInstruction<TProgram extends string = typeof OPPORTUNITY_MAR
         sponsorAccount: TAccountMetas[2];
         tokenMint: TAccountMetas[3];
         sponsorTokenAccount: TAccountMetas[4];
-        /** Market's ATA holding reward tokens */
+        /** Market-owned ATA holding all program-held tokens for this market. */
         marketTokenAta: TAccountMetas[5];
         tokenProgram: TAccountMetas[6];
         systemProgram: TAccountMetas[7];
@@ -1980,47 +1971,59 @@ declare function parseAddRewardInstruction<TProgram extends string, TAccountMeta
  * @see https://github.com/codama-idl/codama
  */
 
-declare const CANCEL_FEE_CLAIMER_CHANGE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getCancelFeeClaimerChangeDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type CancelFeeClaimerChangeInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TAccountCentralState extends string | AccountMeta<string> = string, TAccountTimelockedChange extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
-    TAccountSigner extends string ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
-    TAccountCentralState extends string ? ReadonlyAccount<TAccountCentralState> : TAccountCentralState,
-    TAccountTimelockedChange extends string ? WritableAccount<TAccountTimelockedChange> : TAccountTimelockedChange,
+declare const CLAIM_CREATOR_FEES_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getClaimCreatorFeesDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type ClaimCreatorFeesInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountTokenMint extends string | AccountMeta<string> = string, TAccountMarketTokenAta extends string | AccountMeta<string> = string, TAccountDestinationTokenAccount extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountSigner extends string ? ReadonlySignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
+    TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
+    TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
+    TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
+    TAccountDestinationTokenAccount extends string ? WritableAccount<TAccountDestinationTokenAccount> : TAccountDestinationTokenAccount,
+    TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
     ...TRemainingAccounts
 ]>;
-type CancelFeeClaimerChangeInstructionData = {
+type ClaimCreatorFeesInstructionData = {
     discriminator: ReadonlyUint8Array;
 };
-type CancelFeeClaimerChangeInstructionDataArgs = {};
-declare function getCancelFeeClaimerChangeInstructionDataEncoder(): FixedSizeEncoder<CancelFeeClaimerChangeInstructionDataArgs>;
-declare function getCancelFeeClaimerChangeInstructionDataDecoder(): FixedSizeDecoder<CancelFeeClaimerChangeInstructionData>;
-declare function getCancelFeeClaimerChangeInstructionDataCodec(): FixedSizeCodec<CancelFeeClaimerChangeInstructionDataArgs, CancelFeeClaimerChangeInstructionData>;
-type CancelFeeClaimerChangeAsyncInput<TAccountSigner extends string = string, TAccountCentralState extends string = string, TAccountTimelockedChange extends string = string> = {
+type ClaimCreatorFeesInstructionDataArgs = {};
+declare function getClaimCreatorFeesInstructionDataEncoder(): FixedSizeEncoder<ClaimCreatorFeesInstructionDataArgs>;
+declare function getClaimCreatorFeesInstructionDataDecoder(): FixedSizeDecoder<ClaimCreatorFeesInstructionData>;
+declare function getClaimCreatorFeesInstructionDataCodec(): FixedSizeCodec<ClaimCreatorFeesInstructionDataArgs, ClaimCreatorFeesInstructionData>;
+type ClaimCreatorFeesAsyncInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountTokenMint extends string = string, TAccountMarketTokenAta extends string = string, TAccountDestinationTokenAccount extends string = string, TAccountTokenProgram extends string = string> = {
     signer: TransactionSigner<TAccountSigner>;
-    centralState?: Address<TAccountCentralState>;
-    timelockedChange?: Address<TAccountTimelockedChange>;
+    market: Address<TAccountMarket>;
+    tokenMint: Address<TAccountTokenMint>;
+    marketTokenAta?: Address<TAccountMarketTokenAta>;
+    destinationTokenAccount: Address<TAccountDestinationTokenAccount>;
+    tokenProgram: Address<TAccountTokenProgram>;
 };
-declare function getCancelFeeClaimerChangeInstructionAsync<TAccountSigner extends string, TAccountCentralState extends string, TAccountTimelockedChange extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: CancelFeeClaimerChangeAsyncInput<TAccountSigner, TAccountCentralState, TAccountTimelockedChange>, config?: {
+declare function getClaimCreatorFeesInstructionAsync<TAccountSigner extends string, TAccountMarket extends string, TAccountTokenMint extends string, TAccountMarketTokenAta extends string, TAccountDestinationTokenAccount extends string, TAccountTokenProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ClaimCreatorFeesAsyncInput<TAccountSigner, TAccountMarket, TAccountTokenMint, TAccountMarketTokenAta, TAccountDestinationTokenAccount, TAccountTokenProgram>, config?: {
     programAddress?: TProgramAddress;
-}): Promise<CancelFeeClaimerChangeInstruction<TProgramAddress, TAccountSigner, TAccountCentralState, TAccountTimelockedChange>>;
-type CancelFeeClaimerChangeInput<TAccountSigner extends string = string, TAccountCentralState extends string = string, TAccountTimelockedChange extends string = string> = {
+}): Promise<ClaimCreatorFeesInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountTokenMint, TAccountMarketTokenAta, TAccountDestinationTokenAccount, TAccountTokenProgram>>;
+type ClaimCreatorFeesInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountTokenMint extends string = string, TAccountMarketTokenAta extends string = string, TAccountDestinationTokenAccount extends string = string, TAccountTokenProgram extends string = string> = {
     signer: TransactionSigner<TAccountSigner>;
-    centralState: Address<TAccountCentralState>;
-    timelockedChange: Address<TAccountTimelockedChange>;
+    market: Address<TAccountMarket>;
+    tokenMint: Address<TAccountTokenMint>;
+    marketTokenAta: Address<TAccountMarketTokenAta>;
+    destinationTokenAccount: Address<TAccountDestinationTokenAccount>;
+    tokenProgram: Address<TAccountTokenProgram>;
 };
-declare function getCancelFeeClaimerChangeInstruction<TAccountSigner extends string, TAccountCentralState extends string, TAccountTimelockedChange extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: CancelFeeClaimerChangeInput<TAccountSigner, TAccountCentralState, TAccountTimelockedChange>, config?: {
+declare function getClaimCreatorFeesInstruction<TAccountSigner extends string, TAccountMarket extends string, TAccountTokenMint extends string, TAccountMarketTokenAta extends string, TAccountDestinationTokenAccount extends string, TAccountTokenProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ClaimCreatorFeesInput<TAccountSigner, TAccountMarket, TAccountTokenMint, TAccountMarketTokenAta, TAccountDestinationTokenAccount, TAccountTokenProgram>, config?: {
     programAddress?: TProgramAddress;
-}): CancelFeeClaimerChangeInstruction<TProgramAddress, TAccountSigner, TAccountCentralState, TAccountTimelockedChange>;
-type ParsedCancelFeeClaimerChangeInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+}): ClaimCreatorFeesInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountTokenMint, TAccountMarketTokenAta, TAccountDestinationTokenAccount, TAccountTokenProgram>;
+type ParsedClaimCreatorFeesInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
         signer: TAccountMetas[0];
-        centralState: TAccountMetas[1];
-        timelockedChange: TAccountMetas[2];
+        market: TAccountMetas[1];
+        tokenMint: TAccountMetas[2];
+        marketTokenAta: TAccountMetas[3];
+        destinationTokenAccount: TAccountMetas[4];
+        tokenProgram: TAccountMetas[5];
     };
-    data: CancelFeeClaimerChangeInstructionData;
+    data: ClaimCreatorFeesInstructionData;
 };
-declare function parseCancelFeeClaimerChangeInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCancelFeeClaimerChangeInstruction<TProgram, TAccountMetas>;
+declare function parseClaimCreatorFeesInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedClaimCreatorFeesInstruction<TProgram, TAccountMetas>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -2030,47 +2033,63 @@ declare function parseCancelFeeClaimerChangeInstruction<TProgram extends string,
  * @see https://github.com/codama-idl/codama
  */
 
-declare const CANCEL_UPDATE_AUTHORITY_CHANGE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getCancelUpdateAuthorityChangeDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type CancelUpdateAuthorityChangeInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TAccountCentralState extends string | AccountMeta<string> = string, TAccountTimelockedChange extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
-    TAccountSigner extends string ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
-    TAccountCentralState extends string ? ReadonlyAccount<TAccountCentralState> : TAccountCentralState,
-    TAccountTimelockedChange extends string ? WritableAccount<TAccountTimelockedChange> : TAccountTimelockedChange,
+declare const CLAIM_FEES_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getClaimFeesDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type ClaimFeesInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountPlatformConfig extends string | AccountMeta<string> = string, TAccountTokenMint extends string | AccountMeta<string> = string, TAccountMarketTokenAta extends string | AccountMeta<string> = string, TAccountDestinationTokenAccount extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountSigner extends string ? ReadonlySignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
+    TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
+    TAccountPlatformConfig extends string ? ReadonlyAccount<TAccountPlatformConfig> : TAccountPlatformConfig,
+    TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
+    TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
+    TAccountDestinationTokenAccount extends string ? WritableAccount<TAccountDestinationTokenAccount> : TAccountDestinationTokenAccount,
+    TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
     ...TRemainingAccounts
 ]>;
-type CancelUpdateAuthorityChangeInstructionData = {
+type ClaimFeesInstructionData = {
     discriminator: ReadonlyUint8Array;
 };
-type CancelUpdateAuthorityChangeInstructionDataArgs = {};
-declare function getCancelUpdateAuthorityChangeInstructionDataEncoder(): FixedSizeEncoder<CancelUpdateAuthorityChangeInstructionDataArgs>;
-declare function getCancelUpdateAuthorityChangeInstructionDataDecoder(): FixedSizeDecoder<CancelUpdateAuthorityChangeInstructionData>;
-declare function getCancelUpdateAuthorityChangeInstructionDataCodec(): FixedSizeCodec<CancelUpdateAuthorityChangeInstructionDataArgs, CancelUpdateAuthorityChangeInstructionData>;
-type CancelUpdateAuthorityChangeAsyncInput<TAccountSigner extends string = string, TAccountCentralState extends string = string, TAccountTimelockedChange extends string = string> = {
+type ClaimFeesInstructionDataArgs = {};
+declare function getClaimFeesInstructionDataEncoder(): FixedSizeEncoder<ClaimFeesInstructionDataArgs>;
+declare function getClaimFeesInstructionDataDecoder(): FixedSizeDecoder<ClaimFeesInstructionData>;
+declare function getClaimFeesInstructionDataCodec(): FixedSizeCodec<ClaimFeesInstructionDataArgs, ClaimFeesInstructionData>;
+type ClaimFeesAsyncInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountPlatformConfig extends string = string, TAccountTokenMint extends string = string, TAccountMarketTokenAta extends string = string, TAccountDestinationTokenAccount extends string = string, TAccountTokenProgram extends string = string> = {
     signer: TransactionSigner<TAccountSigner>;
-    centralState?: Address<TAccountCentralState>;
-    timelockedChange?: Address<TAccountTimelockedChange>;
+    market: Address<TAccountMarket>;
+    platformConfig: Address<TAccountPlatformConfig>;
+    tokenMint: Address<TAccountTokenMint>;
+    marketTokenAta?: Address<TAccountMarketTokenAta>;
+    destinationTokenAccount: Address<TAccountDestinationTokenAccount>;
+    tokenProgram: Address<TAccountTokenProgram>;
 };
-declare function getCancelUpdateAuthorityChangeInstructionAsync<TAccountSigner extends string, TAccountCentralState extends string, TAccountTimelockedChange extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: CancelUpdateAuthorityChangeAsyncInput<TAccountSigner, TAccountCentralState, TAccountTimelockedChange>, config?: {
+declare function getClaimFeesInstructionAsync<TAccountSigner extends string, TAccountMarket extends string, TAccountPlatformConfig extends string, TAccountTokenMint extends string, TAccountMarketTokenAta extends string, TAccountDestinationTokenAccount extends string, TAccountTokenProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ClaimFeesAsyncInput<TAccountSigner, TAccountMarket, TAccountPlatformConfig, TAccountTokenMint, TAccountMarketTokenAta, TAccountDestinationTokenAccount, TAccountTokenProgram>, config?: {
     programAddress?: TProgramAddress;
-}): Promise<CancelUpdateAuthorityChangeInstruction<TProgramAddress, TAccountSigner, TAccountCentralState, TAccountTimelockedChange>>;
-type CancelUpdateAuthorityChangeInput<TAccountSigner extends string = string, TAccountCentralState extends string = string, TAccountTimelockedChange extends string = string> = {
+}): Promise<ClaimFeesInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountPlatformConfig, TAccountTokenMint, TAccountMarketTokenAta, TAccountDestinationTokenAccount, TAccountTokenProgram>>;
+type ClaimFeesInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountPlatformConfig extends string = string, TAccountTokenMint extends string = string, TAccountMarketTokenAta extends string = string, TAccountDestinationTokenAccount extends string = string, TAccountTokenProgram extends string = string> = {
     signer: TransactionSigner<TAccountSigner>;
-    centralState: Address<TAccountCentralState>;
-    timelockedChange: Address<TAccountTimelockedChange>;
+    market: Address<TAccountMarket>;
+    platformConfig: Address<TAccountPlatformConfig>;
+    tokenMint: Address<TAccountTokenMint>;
+    marketTokenAta: Address<TAccountMarketTokenAta>;
+    destinationTokenAccount: Address<TAccountDestinationTokenAccount>;
+    tokenProgram: Address<TAccountTokenProgram>;
 };
-declare function getCancelUpdateAuthorityChangeInstruction<TAccountSigner extends string, TAccountCentralState extends string, TAccountTimelockedChange extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: CancelUpdateAuthorityChangeInput<TAccountSigner, TAccountCentralState, TAccountTimelockedChange>, config?: {
+declare function getClaimFeesInstruction<TAccountSigner extends string, TAccountMarket extends string, TAccountPlatformConfig extends string, TAccountTokenMint extends string, TAccountMarketTokenAta extends string, TAccountDestinationTokenAccount extends string, TAccountTokenProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ClaimFeesInput<TAccountSigner, TAccountMarket, TAccountPlatformConfig, TAccountTokenMint, TAccountMarketTokenAta, TAccountDestinationTokenAccount, TAccountTokenProgram>, config?: {
     programAddress?: TProgramAddress;
-}): CancelUpdateAuthorityChangeInstruction<TProgramAddress, TAccountSigner, TAccountCentralState, TAccountTimelockedChange>;
-type ParsedCancelUpdateAuthorityChangeInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+}): ClaimFeesInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountPlatformConfig, TAccountTokenMint, TAccountMarketTokenAta, TAccountDestinationTokenAccount, TAccountTokenProgram>;
+type ParsedClaimFeesInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
         signer: TAccountMetas[0];
-        centralState: TAccountMetas[1];
-        timelockedChange: TAccountMetas[2];
+        market: TAccountMetas[1];
+        platformConfig: TAccountMetas[2];
+        tokenMint: TAccountMetas[3];
+        marketTokenAta: TAccountMetas[4];
+        destinationTokenAccount: TAccountMetas[5];
+        tokenProgram: TAccountMetas[6];
     };
-    data: CancelUpdateAuthorityChangeInstructionData;
+    data: ClaimFeesInstructionData;
 };
-declare function parseCancelUpdateAuthorityChangeInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCancelUpdateAuthorityChangeInstruction<TProgram, TAccountMetas>;
+declare function parseClaimFeesInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedClaimFeesInstruction<TProgram, TAccountMetas>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -2080,63 +2099,60 @@ declare function parseCancelUpdateAuthorityChangeInstruction<TProgram extends st
  * @see https://github.com/codama-idl/codama
  */
 
-declare const CLAIM_FEES_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getClaimFeesDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type ClaimFeesInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TAccountCentralState extends string | AccountMeta<string> = string, TAccountTokenMint extends string | AccountMeta<string> = string, TAccountTokenVault extends string | AccountMeta<string> = string, TAccountTokenVaultAta extends string | AccountMeta<string> = string, TAccountDestinationTokenAccount extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
-    TAccountSigner extends string ? ReadonlySignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
-    TAccountCentralState extends string ? ReadonlyAccount<TAccountCentralState> : TAccountCentralState,
-    TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
-    TAccountTokenVault extends string ? WritableAccount<TAccountTokenVault> : TAccountTokenVault,
-    TAccountTokenVaultAta extends string ? WritableAccount<TAccountTokenVaultAta> : TAccountTokenVaultAta,
-    TAccountDestinationTokenAccount extends string ? WritableAccount<TAccountDestinationTokenAccount> : TAccountDestinationTokenAccount,
-    TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
+declare const CLOSE_OPTION_ACCOUNT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getCloseOptionAccountDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type CloseOptionAccountInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TAccountCreator extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountOption extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountSigner extends string ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
+    TAccountCreator extends string ? WritableAccount<TAccountCreator> : TAccountCreator,
+    TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
+    TAccountOption extends string ? WritableAccount<TAccountOption> : TAccountOption,
+    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
     ...TRemainingAccounts
 ]>;
-type ClaimFeesInstructionData = {
+type CloseOptionAccountInstructionData = {
     discriminator: ReadonlyUint8Array;
+    optionId: bigint;
 };
-type ClaimFeesInstructionDataArgs = {};
-declare function getClaimFeesInstructionDataEncoder(): FixedSizeEncoder<ClaimFeesInstructionDataArgs>;
-declare function getClaimFeesInstructionDataDecoder(): FixedSizeDecoder<ClaimFeesInstructionData>;
-declare function getClaimFeesInstructionDataCodec(): FixedSizeCodec<ClaimFeesInstructionDataArgs, ClaimFeesInstructionData>;
-type ClaimFeesAsyncInput<TAccountSigner extends string = string, TAccountCentralState extends string = string, TAccountTokenMint extends string = string, TAccountTokenVault extends string = string, TAccountTokenVaultAta extends string = string, TAccountDestinationTokenAccount extends string = string, TAccountTokenProgram extends string = string> = {
+type CloseOptionAccountInstructionDataArgs = {
+    optionId: number | bigint;
+};
+declare function getCloseOptionAccountInstructionDataEncoder(): FixedSizeEncoder<CloseOptionAccountInstructionDataArgs>;
+declare function getCloseOptionAccountInstructionDataDecoder(): FixedSizeDecoder<CloseOptionAccountInstructionData>;
+declare function getCloseOptionAccountInstructionDataCodec(): FixedSizeCodec<CloseOptionAccountInstructionDataArgs, CloseOptionAccountInstructionData>;
+type CloseOptionAccountAsyncInput<TAccountSigner extends string = string, TAccountCreator extends string = string, TAccountMarket extends string = string, TAccountOption extends string = string, TAccountSystemProgram extends string = string> = {
     signer: TransactionSigner<TAccountSigner>;
-    centralState?: Address<TAccountCentralState>;
-    tokenMint: Address<TAccountTokenMint>;
-    tokenVault?: Address<TAccountTokenVault>;
-    tokenVaultAta?: Address<TAccountTokenVaultAta>;
-    destinationTokenAccount: Address<TAccountDestinationTokenAccount>;
-    tokenProgram: Address<TAccountTokenProgram>;
+    creator: Address<TAccountCreator>;
+    market: Address<TAccountMarket>;
+    option?: Address<TAccountOption>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    optionId: CloseOptionAccountInstructionDataArgs['optionId'];
 };
-declare function getClaimFeesInstructionAsync<TAccountSigner extends string, TAccountCentralState extends string, TAccountTokenMint extends string, TAccountTokenVault extends string, TAccountTokenVaultAta extends string, TAccountDestinationTokenAccount extends string, TAccountTokenProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ClaimFeesAsyncInput<TAccountSigner, TAccountCentralState, TAccountTokenMint, TAccountTokenVault, TAccountTokenVaultAta, TAccountDestinationTokenAccount, TAccountTokenProgram>, config?: {
+declare function getCloseOptionAccountInstructionAsync<TAccountSigner extends string, TAccountCreator extends string, TAccountMarket extends string, TAccountOption extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: CloseOptionAccountAsyncInput<TAccountSigner, TAccountCreator, TAccountMarket, TAccountOption, TAccountSystemProgram>, config?: {
     programAddress?: TProgramAddress;
-}): Promise<ClaimFeesInstruction<TProgramAddress, TAccountSigner, TAccountCentralState, TAccountTokenMint, TAccountTokenVault, TAccountTokenVaultAta, TAccountDestinationTokenAccount, TAccountTokenProgram>>;
-type ClaimFeesInput<TAccountSigner extends string = string, TAccountCentralState extends string = string, TAccountTokenMint extends string = string, TAccountTokenVault extends string = string, TAccountTokenVaultAta extends string = string, TAccountDestinationTokenAccount extends string = string, TAccountTokenProgram extends string = string> = {
+}): Promise<CloseOptionAccountInstruction<TProgramAddress, TAccountSigner, TAccountCreator, TAccountMarket, TAccountOption, TAccountSystemProgram>>;
+type CloseOptionAccountInput<TAccountSigner extends string = string, TAccountCreator extends string = string, TAccountMarket extends string = string, TAccountOption extends string = string, TAccountSystemProgram extends string = string> = {
     signer: TransactionSigner<TAccountSigner>;
-    centralState: Address<TAccountCentralState>;
-    tokenMint: Address<TAccountTokenMint>;
-    tokenVault: Address<TAccountTokenVault>;
-    tokenVaultAta: Address<TAccountTokenVaultAta>;
-    destinationTokenAccount: Address<TAccountDestinationTokenAccount>;
-    tokenProgram: Address<TAccountTokenProgram>;
+    creator: Address<TAccountCreator>;
+    market: Address<TAccountMarket>;
+    option: Address<TAccountOption>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    optionId: CloseOptionAccountInstructionDataArgs['optionId'];
 };
-declare function getClaimFeesInstruction<TAccountSigner extends string, TAccountCentralState extends string, TAccountTokenMint extends string, TAccountTokenVault extends string, TAccountTokenVaultAta extends string, TAccountDestinationTokenAccount extends string, TAccountTokenProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ClaimFeesInput<TAccountSigner, TAccountCentralState, TAccountTokenMint, TAccountTokenVault, TAccountTokenVaultAta, TAccountDestinationTokenAccount, TAccountTokenProgram>, config?: {
+declare function getCloseOptionAccountInstruction<TAccountSigner extends string, TAccountCreator extends string, TAccountMarket extends string, TAccountOption extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: CloseOptionAccountInput<TAccountSigner, TAccountCreator, TAccountMarket, TAccountOption, TAccountSystemProgram>, config?: {
     programAddress?: TProgramAddress;
-}): ClaimFeesInstruction<TProgramAddress, TAccountSigner, TAccountCentralState, TAccountTokenMint, TAccountTokenVault, TAccountTokenVaultAta, TAccountDestinationTokenAccount, TAccountTokenProgram>;
-type ParsedClaimFeesInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+}): CloseOptionAccountInstruction<TProgramAddress, TAccountSigner, TAccountCreator, TAccountMarket, TAccountOption, TAccountSystemProgram>;
+type ParsedCloseOptionAccountInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
         signer: TAccountMetas[0];
-        centralState: TAccountMetas[1];
-        tokenMint: TAccountMetas[2];
-        tokenVault: TAccountMetas[3];
-        tokenVaultAta: TAccountMetas[4];
-        destinationTokenAccount: TAccountMetas[5];
-        tokenProgram: TAccountMetas[6];
+        creator: TAccountMetas[1];
+        market: TAccountMetas[2];
+        option: TAccountMetas[3];
+        systemProgram: TAccountMetas[4];
     };
-    data: ClaimFeesInstructionData;
+    data: CloseOptionAccountInstructionData;
 };
-declare function parseClaimFeesInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedClaimFeesInstruction<TProgram, TAccountMetas>;
+declare function parseCloseOptionAccountInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCloseOptionAccountInstruction<TProgram, TAccountMetas>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -2152,7 +2168,7 @@ type CloseStakeAccountInstruction<TProgram extends string = typeof OPPORTUNITY_M
     TAccountOwner extends string ? WritableSignerAccount<TAccountOwner> & AccountSignerMeta<TAccountOwner> : TAccountOwner,
     TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
     TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
-    TAccountOption extends string ? ReadonlyAccount<TAccountOption> : TAccountOption,
+    TAccountOption extends string ? WritableAccount<TAccountOption> : TAccountOption,
     TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
     TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
     TAccountOwnerTokenAccount extends string ? WritableAccount<TAccountOwnerTokenAccount> : TAccountOwnerTokenAccount,
@@ -2178,7 +2194,7 @@ type CloseStakeAccountAsyncInput<TAccountOwner extends string = string, TAccount
     stakeAccount?: Address<TAccountStakeAccount>;
     option?: Address<TAccountOption>;
     tokenMint: Address<TAccountTokenMint>;
-    /** Market's ATA holding reward tokens */
+    /** Market-owned ATA holding all program-held tokens for this market */
     marketTokenAta?: Address<TAccountMarketTokenAta>;
     /** Owner's token account to receive rewards */
     ownerTokenAccount: Address<TAccountOwnerTokenAccount>;
@@ -2196,7 +2212,7 @@ type CloseStakeAccountInput<TAccountOwner extends string = string, TAccountMarke
     stakeAccount: Address<TAccountStakeAccount>;
     option: Address<TAccountOption>;
     tokenMint: Address<TAccountTokenMint>;
-    /** Market's ATA holding reward tokens */
+    /** Market-owned ATA holding all program-held tokens for this market */
     marketTokenAta: Address<TAccountMarketTokenAta>;
     /** Owner's token account to receive rewards */
     ownerTokenAccount: Address<TAccountOwnerTokenAccount>;
@@ -2216,7 +2232,7 @@ type ParsedCloseStakeAccountInstruction<TProgram extends string = typeof OPPORTU
         stakeAccount: TAccountMetas[2];
         option: TAccountMetas[3];
         tokenMint: TAccountMetas[4];
-        /** Market's ATA holding reward tokens */
+        /** Market-owned ATA holding all program-held tokens for this market */
         marketTokenAta: TAccountMetas[5];
         /** Owner's token account to receive rewards */
         ownerTokenAccount: TAccountMetas[6];
@@ -2237,15 +2253,13 @@ declare function parseCloseStakeAccountInstruction<TProgram extends string, TAcc
 
 declare const CLOSE_STUCK_STAKE_ACCOUNT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
 declare function getCloseStuckStakeAccountDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type CloseStuckStakeAccountInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountStakeAccount extends string | AccountMeta<string> = string, TAccountTokenMint extends string | AccountMeta<string> = string, TAccountMarketTokenAta extends string | AccountMeta<string> = string, TAccountSignerTokenAccount extends string | AccountMeta<string> = string, TAccountTokenVault extends string | AccountMeta<string> = string, TAccountTokenVaultAta extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+type CloseStuckStakeAccountInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountStakeAccount extends string | AccountMeta<string> = string, TAccountTokenMint extends string | AccountMeta<string> = string, TAccountSignerTokenAccount extends string | AccountMeta<string> = string, TAccountMarketTokenAta extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
     TAccountSigner extends string ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
     TAccountMarket extends string ? ReadonlyAccount<TAccountMarket> : TAccountMarket,
     TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
     TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
-    TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
     TAccountSignerTokenAccount extends string ? WritableAccount<TAccountSignerTokenAccount> : TAccountSignerTokenAccount,
-    TAccountTokenVault extends string ? WritableAccount<TAccountTokenVault> : TAccountTokenVault,
-    TAccountTokenVaultAta extends string ? WritableAccount<TAccountTokenVaultAta> : TAccountTokenVaultAta,
+    TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
     TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
     TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
     ...TRemainingAccounts
@@ -2260,44 +2274,36 @@ type CloseStuckStakeAccountInstructionDataArgs = {
 declare function getCloseStuckStakeAccountInstructionDataEncoder(): FixedSizeEncoder<CloseStuckStakeAccountInstructionDataArgs>;
 declare function getCloseStuckStakeAccountInstructionDataDecoder(): FixedSizeDecoder<CloseStuckStakeAccountInstructionData>;
 declare function getCloseStuckStakeAccountInstructionDataCodec(): FixedSizeCodec<CloseStuckStakeAccountInstructionDataArgs, CloseStuckStakeAccountInstructionData>;
-type CloseStuckStakeAccountAsyncInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountTokenMint extends string = string, TAccountMarketTokenAta extends string = string, TAccountSignerTokenAccount extends string = string, TAccountTokenVault extends string = string, TAccountTokenVaultAta extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string> = {
+type CloseStuckStakeAccountAsyncInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountTokenMint extends string = string, TAccountSignerTokenAccount extends string = string, TAccountMarketTokenAta extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string> = {
     signer: TransactionSigner<TAccountSigner>;
     market: Address<TAccountMarket>;
     stakeAccount?: Address<TAccountStakeAccount>;
     tokenMint: Address<TAccountTokenMint>;
-    /** Market's ATA holding staked tokens */
-    marketTokenAta?: Address<TAccountMarketTokenAta>;
     /** Signer's token account to receive refund */
     signerTokenAccount: Address<TAccountSignerTokenAccount>;
-    tokenVault?: Address<TAccountTokenVault>;
-    /** Token vault ATA holding fee tokens */
-    tokenVaultAta?: Address<TAccountTokenVaultAta>;
+    marketTokenAta?: Address<TAccountMarketTokenAta>;
     tokenProgram: Address<TAccountTokenProgram>;
     systemProgram?: Address<TAccountSystemProgram>;
     stakeAccountId: CloseStuckStakeAccountInstructionDataArgs['stakeAccountId'];
 };
-declare function getCloseStuckStakeAccountInstructionAsync<TAccountSigner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountTokenMint extends string, TAccountMarketTokenAta extends string, TAccountSignerTokenAccount extends string, TAccountTokenVault extends string, TAccountTokenVaultAta extends string, TAccountTokenProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: CloseStuckStakeAccountAsyncInput<TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountSignerTokenAccount, TAccountTokenVault, TAccountTokenVaultAta, TAccountTokenProgram, TAccountSystemProgram>, config?: {
+declare function getCloseStuckStakeAccountInstructionAsync<TAccountSigner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountTokenMint extends string, TAccountSignerTokenAccount extends string, TAccountMarketTokenAta extends string, TAccountTokenProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: CloseStuckStakeAccountAsyncInput<TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountSignerTokenAccount, TAccountMarketTokenAta, TAccountTokenProgram, TAccountSystemProgram>, config?: {
     programAddress?: TProgramAddress;
-}): Promise<CloseStuckStakeAccountInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountSignerTokenAccount, TAccountTokenVault, TAccountTokenVaultAta, TAccountTokenProgram, TAccountSystemProgram>>;
-type CloseStuckStakeAccountInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountTokenMint extends string = string, TAccountMarketTokenAta extends string = string, TAccountSignerTokenAccount extends string = string, TAccountTokenVault extends string = string, TAccountTokenVaultAta extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string> = {
+}): Promise<CloseStuckStakeAccountInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountSignerTokenAccount, TAccountMarketTokenAta, TAccountTokenProgram, TAccountSystemProgram>>;
+type CloseStuckStakeAccountInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountTokenMint extends string = string, TAccountSignerTokenAccount extends string = string, TAccountMarketTokenAta extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string> = {
     signer: TransactionSigner<TAccountSigner>;
     market: Address<TAccountMarket>;
     stakeAccount: Address<TAccountStakeAccount>;
     tokenMint: Address<TAccountTokenMint>;
-    /** Market's ATA holding staked tokens */
-    marketTokenAta: Address<TAccountMarketTokenAta>;
     /** Signer's token account to receive refund */
     signerTokenAccount: Address<TAccountSignerTokenAccount>;
-    tokenVault: Address<TAccountTokenVault>;
-    /** Token vault ATA holding fee tokens */
-    tokenVaultAta: Address<TAccountTokenVaultAta>;
+    marketTokenAta: Address<TAccountMarketTokenAta>;
     tokenProgram: Address<TAccountTokenProgram>;
     systemProgram?: Address<TAccountSystemProgram>;
     stakeAccountId: CloseStuckStakeAccountInstructionDataArgs['stakeAccountId'];
 };
-declare function getCloseStuckStakeAccountInstruction<TAccountSigner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountTokenMint extends string, TAccountMarketTokenAta extends string, TAccountSignerTokenAccount extends string, TAccountTokenVault extends string, TAccountTokenVaultAta extends string, TAccountTokenProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: CloseStuckStakeAccountInput<TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountSignerTokenAccount, TAccountTokenVault, TAccountTokenVaultAta, TAccountTokenProgram, TAccountSystemProgram>, config?: {
+declare function getCloseStuckStakeAccountInstruction<TAccountSigner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountTokenMint extends string, TAccountSignerTokenAccount extends string, TAccountMarketTokenAta extends string, TAccountTokenProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: CloseStuckStakeAccountInput<TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountSignerTokenAccount, TAccountMarketTokenAta, TAccountTokenProgram, TAccountSystemProgram>, config?: {
     programAddress?: TProgramAddress;
-}): CloseStuckStakeAccountInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountSignerTokenAccount, TAccountTokenVault, TAccountTokenVaultAta, TAccountTokenProgram, TAccountSystemProgram>;
+}): CloseStuckStakeAccountInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountSignerTokenAccount, TAccountMarketTokenAta, TAccountTokenProgram, TAccountSystemProgram>;
 type ParsedCloseStuckStakeAccountInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
@@ -2305,15 +2311,11 @@ type ParsedCloseStuckStakeAccountInstruction<TProgram extends string = typeof OP
         market: TAccountMetas[1];
         stakeAccount: TAccountMetas[2];
         tokenMint: TAccountMetas[3];
-        /** Market's ATA holding staked tokens */
-        marketTokenAta: TAccountMetas[4];
         /** Signer's token account to receive refund */
-        signerTokenAccount: TAccountMetas[5];
-        tokenVault: TAccountMetas[6];
-        /** Token vault ATA holding fee tokens */
-        tokenVaultAta: TAccountMetas[7];
-        tokenProgram: TAccountMetas[8];
-        systemProgram: TAccountMetas[9];
+        signerTokenAccount: TAccountMetas[4];
+        marketTokenAta: TAccountMetas[5];
+        tokenProgram: TAccountMetas[6];
+        systemProgram: TAccountMetas[7];
     };
     data: CloseStuckStakeAccountInstructionData;
 };
@@ -2329,186 +2331,109 @@ declare function parseCloseStuckStakeAccountInstruction<TProgram extends string,
 
 declare const CREATE_MARKET_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
 declare function getCreateMarketDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type CreateMarketInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountCreator extends string | AccountMeta<string> = string, TAccountTokenMint extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountMarketTokenAta extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TAccountTokenProgram extends string | AccountMeta<string> = string, TAccountAssociatedTokenProgram extends string | AccountMeta<string> = 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+type CreateMarketInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountCreator extends string | AccountMeta<string> = string, TAccountPlatformConfig extends string | AccountMeta<string> = string, TAccountTokenMint extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountMarketTokenAta extends string | AccountMeta<string> = string, TAccountAllowedMint extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = string, TAccountAssociatedTokenProgram extends string | AccountMeta<string> = 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL', TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
     TAccountCreator extends string ? WritableSignerAccount<TAccountCreator> & AccountSignerMeta<TAccountCreator> : TAccountCreator,
+    TAccountPlatformConfig extends string ? ReadonlyAccount<TAccountPlatformConfig> : TAccountPlatformConfig,
     TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
     TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
     TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
-    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
+    TAccountAllowedMint extends string ? ReadonlyAccount<TAccountAllowedMint> : TAccountAllowedMint,
     TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
     TAccountAssociatedTokenProgram extends string ? ReadonlyAccount<TAccountAssociatedTokenProgram> : TAccountAssociatedTokenProgram,
+    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
     ...TRemainingAccounts
 ]>;
 type CreateMarketInstructionData = {
     discriminator: ReadonlyUint8Array;
     marketIndex: bigint;
-    timeToStake: bigint;
-    timeToReveal: bigint;
-    marketAuthority: Option<Address>;
-    unstakeDelaySeconds: bigint;
+    marketAuthority: Address;
+    allowUnstakingEarly: boolean;
     authorizedReaderPubkey: Array<number>;
-    allowClosingEarly: boolean;
     revealPeriodAuthority: Address;
     earlinessCutoffSeconds: bigint;
+    earlinessMultiplier: number;
+    minStakeAmount: bigint;
+    creatorFeeClaimer: Address;
 };
 type CreateMarketInstructionDataArgs = {
     marketIndex: number | bigint;
-    timeToStake: number | bigint;
-    timeToReveal: number | bigint;
-    marketAuthority: OptionOrNullable<Address>;
-    unstakeDelaySeconds: number | bigint;
+    marketAuthority: Address;
+    allowUnstakingEarly: boolean;
     authorizedReaderPubkey: Array<number>;
-    allowClosingEarly: boolean;
     revealPeriodAuthority: Address;
     earlinessCutoffSeconds: number | bigint;
-};
-declare function getCreateMarketInstructionDataEncoder(): Encoder<CreateMarketInstructionDataArgs>;
-declare function getCreateMarketInstructionDataDecoder(): Decoder<CreateMarketInstructionData>;
-declare function getCreateMarketInstructionDataCodec(): Codec<CreateMarketInstructionDataArgs, CreateMarketInstructionData>;
-type CreateMarketAsyncInput<TAccountCreator extends string = string, TAccountTokenMint extends string = string, TAccountMarket extends string = string, TAccountMarketTokenAta extends string = string, TAccountSystemProgram extends string = string, TAccountTokenProgram extends string = string, TAccountAssociatedTokenProgram extends string = string> = {
+    earlinessMultiplier: number;
+    minStakeAmount: number | bigint;
+    creatorFeeClaimer: Address;
+};
+declare function getCreateMarketInstructionDataEncoder(): FixedSizeEncoder<CreateMarketInstructionDataArgs>;
+declare function getCreateMarketInstructionDataDecoder(): FixedSizeDecoder<CreateMarketInstructionData>;
+declare function getCreateMarketInstructionDataCodec(): FixedSizeCodec<CreateMarketInstructionDataArgs, CreateMarketInstructionData>;
+type CreateMarketAsyncInput<TAccountCreator extends string = string, TAccountPlatformConfig extends string = string, TAccountTokenMint extends string = string, TAccountMarket extends string = string, TAccountMarketTokenAta extends string = string, TAccountAllowedMint extends string = string, TAccountTokenProgram extends string = string, TAccountAssociatedTokenProgram extends string = string, TAccountSystemProgram extends string = string> = {
     creator: TransactionSigner<TAccountCreator>;
+    platformConfig: Address<TAccountPlatformConfig>;
     tokenMint: Address<TAccountTokenMint>;
     market?: Address<TAccountMarket>;
-    /** ATA owned by market PDA, holds reward tokens */
+    /** This ATA holds all of the market's program-held tokens (stakes, rewards, fees). */
     marketTokenAta?: Address<TAccountMarketTokenAta>;
-    systemProgram?: Address<TAccountSystemProgram>;
+    allowedMint?: Address<TAccountAllowedMint>;
     tokenProgram: Address<TAccountTokenProgram>;
     associatedTokenProgram?: Address<TAccountAssociatedTokenProgram>;
+    systemProgram?: Address<TAccountSystemProgram>;
     marketIndex: CreateMarketInstructionDataArgs['marketIndex'];
-    timeToStake: CreateMarketInstructionDataArgs['timeToStake'];
-    timeToReveal: CreateMarketInstructionDataArgs['timeToReveal'];
     marketAuthority: CreateMarketInstructionDataArgs['marketAuthority'];
-    unstakeDelaySeconds: CreateMarketInstructionDataArgs['unstakeDelaySeconds'];
+    allowUnstakingEarly: CreateMarketInstructionDataArgs['allowUnstakingEarly'];
     authorizedReaderPubkey: CreateMarketInstructionDataArgs['authorizedReaderPubkey'];
-    allowClosingEarly: CreateMarketInstructionDataArgs['allowClosingEarly'];
     revealPeriodAuthority: CreateMarketInstructionDataArgs['revealPeriodAuthority'];
     earlinessCutoffSeconds: CreateMarketInstructionDataArgs['earlinessCutoffSeconds'];
+    earlinessMultiplier: CreateMarketInstructionDataArgs['earlinessMultiplier'];
+    minStakeAmount: CreateMarketInstructionDataArgs['minStakeAmount'];
+    creatorFeeClaimer: CreateMarketInstructionDataArgs['creatorFeeClaimer'];
 };
-declare function getCreateMarketInstructionAsync<TAccountCreator extends string, TAccountTokenMint extends string, TAccountMarket extends string, TAccountMarketTokenAta extends string, TAccountSystemProgram extends string, TAccountTokenProgram extends string, TAccountAssociatedTokenProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: CreateMarketAsyncInput<TAccountCreator, TAccountTokenMint, TAccountMarket, TAccountMarketTokenAta, TAccountSystemProgram, TAccountTokenProgram, TAccountAssociatedTokenProgram>, config?: {
+declare function getCreateMarketInstructionAsync<TAccountCreator extends string, TAccountPlatformConfig extends string, TAccountTokenMint extends string, TAccountMarket extends string, TAccountMarketTokenAta extends string, TAccountAllowedMint extends string, TAccountTokenProgram extends string, TAccountAssociatedTokenProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: CreateMarketAsyncInput<TAccountCreator, TAccountPlatformConfig, TAccountTokenMint, TAccountMarket, TAccountMarketTokenAta, TAccountAllowedMint, TAccountTokenProgram, TAccountAssociatedTokenProgram, TAccountSystemProgram>, config?: {
     programAddress?: TProgramAddress;
-}): Promise<CreateMarketInstruction<TProgramAddress, TAccountCreator, TAccountTokenMint, TAccountMarket, TAccountMarketTokenAta, TAccountSystemProgram, TAccountTokenProgram, TAccountAssociatedTokenProgram>>;
-type CreateMarketInput<TAccountCreator extends string = string, TAccountTokenMint extends string = string, TAccountMarket extends string = string, TAccountMarketTokenAta extends string = string, TAccountSystemProgram extends string = string, TAccountTokenProgram extends string = string, TAccountAssociatedTokenProgram extends string = string> = {
+}): Promise<CreateMarketInstruction<TProgramAddress, TAccountCreator, TAccountPlatformConfig, TAccountTokenMint, TAccountMarket, TAccountMarketTokenAta, TAccountAllowedMint, TAccountTokenProgram, TAccountAssociatedTokenProgram, TAccountSystemProgram>>;
+type CreateMarketInput<TAccountCreator extends string = string, TAccountPlatformConfig extends string = string, TAccountTokenMint extends string = string, TAccountMarket extends string = string, TAccountMarketTokenAta extends string = string, TAccountAllowedMint extends string = string, TAccountTokenProgram extends string = string, TAccountAssociatedTokenProgram extends string = string, TAccountSystemProgram extends string = string> = {
     creator: TransactionSigner<TAccountCreator>;
+    platformConfig: Address<TAccountPlatformConfig>;
     tokenMint: Address<TAccountTokenMint>;
     market: Address<TAccountMarket>;
-    /** ATA owned by market PDA, holds reward tokens */
+    /** This ATA holds all of the market's program-held tokens (stakes, rewards, fees). */
     marketTokenAta: Address<TAccountMarketTokenAta>;
-    systemProgram?: Address<TAccountSystemProgram>;
+    allowedMint: Address<TAccountAllowedMint>;
     tokenProgram: Address<TAccountTokenProgram>;
     associatedTokenProgram?: Address<TAccountAssociatedTokenProgram>;
+    systemProgram?: Address<TAccountSystemProgram>;
     marketIndex: CreateMarketInstructionDataArgs['marketIndex'];
-    timeToStake: CreateMarketInstructionDataArgs['timeToStake'];
-    timeToReveal: CreateMarketInstructionDataArgs['timeToReveal'];
     marketAuthority: CreateMarketInstructionDataArgs['marketAuthority'];
-    unstakeDelaySeconds: CreateMarketInstructionDataArgs['unstakeDelaySeconds'];
+    allowUnstakingEarly: CreateMarketInstructionDataArgs['allowUnstakingEarly'];
     authorizedReaderPubkey: CreateMarketInstructionDataArgs['authorizedReaderPubkey'];
-    allowClosingEarly: CreateMarketInstructionDataArgs['allowClosingEarly'];
     revealPeriodAuthority: CreateMarketInstructionDataArgs['revealPeriodAuthority'];
     earlinessCutoffSeconds: CreateMarketInstructionDataArgs['earlinessCutoffSeconds'];
+    earlinessMultiplier: CreateMarketInstructionDataArgs['earlinessMultiplier'];
+    minStakeAmount: CreateMarketInstructionDataArgs['minStakeAmount'];
+    creatorFeeClaimer: CreateMarketInstructionDataArgs['creatorFeeClaimer'];
 };
-declare function getCreateMarketInstruction<TAccountCreator extends string, TAccountTokenMint extends string, TAccountMarket extends string, TAccountMarketTokenAta extends string, TAccountSystemProgram extends string, TAccountTokenProgram extends string, TAccountAssociatedTokenProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: CreateMarketInput<TAccountCreator, TAccountTokenMint, TAccountMarket, TAccountMarketTokenAta, TAccountSystemProgram, TAccountTokenProgram, TAccountAssociatedTokenProgram>, config?: {
+declare function getCreateMarketInstruction<TAccountCreator extends string, TAccountPlatformConfig extends string, TAccountTokenMint extends string, TAccountMarket extends string, TAccountMarketTokenAta extends string, TAccountAllowedMint extends string, TAccountTokenProgram extends string, TAccountAssociatedTokenProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: CreateMarketInput<TAccountCreator, TAccountPlatformConfig, TAccountTokenMint, TAccountMarket, TAccountMarketTokenAta, TAccountAllowedMint, TAccountTokenProgram, TAccountAssociatedTokenProgram, TAccountSystemProgram>, config?: {
     programAddress?: TProgramAddress;
-}): CreateMarketInstruction<TProgramAddress, TAccountCreator, TAccountTokenMint, TAccountMarket, TAccountMarketTokenAta, TAccountSystemProgram, TAccountTokenProgram, TAccountAssociatedTokenProgram>;
+}): CreateMarketInstruction<TProgramAddress, TAccountCreator, TAccountPlatformConfig, TAccountTokenMint, TAccountMarket, TAccountMarketTokenAta, TAccountAllowedMint, TAccountTokenProgram, TAccountAssociatedTokenProgram, TAccountSystemProgram>;
 type ParsedCreateMarketInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
         creator: TAccountMetas[0];
-        tokenMint: TAccountMetas[1];
-        market: TAccountMetas[2];
-        /** ATA owned by market PDA, holds reward tokens */
-        marketTokenAta: TAccountMetas[3];
-        systemProgram: TAccountMetas[4];
-        tokenProgram: TAccountMetas[5];
-        associatedTokenProgram: TAccountMetas[6];
-    };
-    data: CreateMarketInstructionData;
-};
-declare function parseCreateMarketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCreateMarketInstruction<TProgram, TAccountMetas>;
-
-/**
- * This code was AUTOGENERATED using the Codama library.
- * Please DO NOT EDIT THIS FILE, instead use visitors
- * to add features, then rerun Codama to update it.
- *
- * @see https://github.com/codama-idl/codama
- */
-
-declare const DO_UNSTAKE_EARLY_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getDoUnstakeEarlyDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type DoUnstakeEarlyInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountStakeAccount extends string | AccountMeta<string> = string, TAccountTokenMint extends string | AccountMeta<string> = string, TAccountMarketTokenAta extends string | AccountMeta<string> = string, TAccountOwnerTokenAccount extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
-    TAccountSigner extends string ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
-    TAccountMarket extends string ? ReadonlyAccount<TAccountMarket> : TAccountMarket,
-    TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
-    TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
-    TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
-    TAccountOwnerTokenAccount extends string ? WritableAccount<TAccountOwnerTokenAccount> : TAccountOwnerTokenAccount,
-    TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
-    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
-    ...TRemainingAccounts
-]>;
-type DoUnstakeEarlyInstructionData = {
-    discriminator: ReadonlyUint8Array;
-    stakeAccountId: number;
-    stakeAccountOwner: Address;
-};
-type DoUnstakeEarlyInstructionDataArgs = {
-    stakeAccountId: number;
-    stakeAccountOwner: Address;
-};
-declare function getDoUnstakeEarlyInstructionDataEncoder(): FixedSizeEncoder<DoUnstakeEarlyInstructionDataArgs>;
-declare function getDoUnstakeEarlyInstructionDataDecoder(): FixedSizeDecoder<DoUnstakeEarlyInstructionData>;
-declare function getDoUnstakeEarlyInstructionDataCodec(): FixedSizeCodec<DoUnstakeEarlyInstructionDataArgs, DoUnstakeEarlyInstructionData>;
-type DoUnstakeEarlyAsyncInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountTokenMint extends string = string, TAccountMarketTokenAta extends string = string, TAccountOwnerTokenAccount extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string> = {
-    signer: TransactionSigner<TAccountSigner>;
-    market: Address<TAccountMarket>;
-    stakeAccount?: Address<TAccountStakeAccount>;
-    tokenMint: Address<TAccountTokenMint>;
-    /** Market's ATA holding staked tokens */
-    marketTokenAta?: Address<TAccountMarketTokenAta>;
-    /** Owner's token account to receive refund */
-    ownerTokenAccount: Address<TAccountOwnerTokenAccount>;
-    tokenProgram: Address<TAccountTokenProgram>;
-    systemProgram?: Address<TAccountSystemProgram>;
-    stakeAccountId: DoUnstakeEarlyInstructionDataArgs['stakeAccountId'];
-    stakeAccountOwner: DoUnstakeEarlyInstructionDataArgs['stakeAccountOwner'];
-};
-declare function getDoUnstakeEarlyInstructionAsync<TAccountSigner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountTokenMint extends string, TAccountMarketTokenAta extends string, TAccountOwnerTokenAccount extends string, TAccountTokenProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: DoUnstakeEarlyAsyncInput<TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountOwnerTokenAccount, TAccountTokenProgram, TAccountSystemProgram>, config?: {
-    programAddress?: TProgramAddress;
-}): Promise<DoUnstakeEarlyInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountOwnerTokenAccount, TAccountTokenProgram, TAccountSystemProgram>>;
-type DoUnstakeEarlyInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountTokenMint extends string = string, TAccountMarketTokenAta extends string = string, TAccountOwnerTokenAccount extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string> = {
-    signer: TransactionSigner<TAccountSigner>;
-    market: Address<TAccountMarket>;
-    stakeAccount: Address<TAccountStakeAccount>;
-    tokenMint: Address<TAccountTokenMint>;
-    /** Market's ATA holding staked tokens */
-    marketTokenAta: Address<TAccountMarketTokenAta>;
-    /** Owner's token account to receive refund */
-    ownerTokenAccount: Address<TAccountOwnerTokenAccount>;
-    tokenProgram: Address<TAccountTokenProgram>;
-    systemProgram?: Address<TAccountSystemProgram>;
-    stakeAccountId: DoUnstakeEarlyInstructionDataArgs['stakeAccountId'];
-    stakeAccountOwner: DoUnstakeEarlyInstructionDataArgs['stakeAccountOwner'];
-};
-declare function getDoUnstakeEarlyInstruction<TAccountSigner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountTokenMint extends string, TAccountMarketTokenAta extends string, TAccountOwnerTokenAccount extends string, TAccountTokenProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: DoUnstakeEarlyInput<TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountOwnerTokenAccount, TAccountTokenProgram, TAccountSystemProgram>, config?: {
-    programAddress?: TProgramAddress;
-}): DoUnstakeEarlyInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountOwnerTokenAccount, TAccountTokenProgram, TAccountSystemProgram>;
-type ParsedDoUnstakeEarlyInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
-    programAddress: Address<TProgram>;
-    accounts: {
-        signer: TAccountMetas[0];
-        market: TAccountMetas[1];
-        stakeAccount: TAccountMetas[2];
-        tokenMint: TAccountMetas[3];
-        /** Market's ATA holding staked tokens */
+        platformConfig: TAccountMetas[1];
+        tokenMint: TAccountMetas[2];
+        market: TAccountMetas[3];
+        /** This ATA holds all of the market's program-held tokens (stakes, rewards, fees). */
         marketTokenAta: TAccountMetas[4];
-        /** Owner's token account to receive refund */
-        ownerTokenAccount: TAccountMetas[5];
+        allowedMint: TAccountMetas[5];
         tokenProgram: TAccountMetas[6];
-        systemProgram: TAccountMetas[7];
+        associatedTokenProgram: TAccountMetas[7];
+        systemProgram: TAccountMetas[8];
     };
-    data: DoUnstakeEarlyInstructionData;
+    data: CreateMarketInstructionData;
 };
-declare function parseDoUnstakeEarlyInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedDoUnstakeEarlyInstruction<TProgram, TAccountMetas>;
+declare function parseCreateMarketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCreateMarketInstruction<TProgram, TAccountMetas>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -2520,8 +2445,8 @@ declare function parseDoUnstakeEarlyInstruction<TProgram extends string, TAccoun
 
 declare const END_REVEAL_PERIOD_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
 declare function getEndRevealPeriodDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type EndRevealPeriodInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountAuthority extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
-    TAccountAuthority extends string ? ReadonlySignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority> : TAccountAuthority,
+type EndRevealPeriodInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountSigner extends string ? ReadonlySignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
     TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
     ...TRemainingAccounts
 ]>;
@@ -2532,17 +2457,17 @@ type EndRevealPeriodInstructionDataArgs = {};
 declare function getEndRevealPeriodInstructionDataEncoder(): FixedSizeEncoder<EndRevealPeriodInstructionDataArgs>;
 declare function getEndRevealPeriodInstructionDataDecoder(): FixedSizeDecoder<EndRevealPeriodInstructionData>;
 declare function getEndRevealPeriodInstructionDataCodec(): FixedSizeCodec<EndRevealPeriodInstructionDataArgs, EndRevealPeriodInstructionData>;
-type EndRevealPeriodInput<TAccountAuthority extends string = string, TAccountMarket extends string = string> = {
-    authority: TransactionSigner<TAccountAuthority>;
+type EndRevealPeriodInput<TAccountSigner extends string = string, TAccountMarket extends string = string> = {
+    signer: TransactionSigner<TAccountSigner>;
     market: Address<TAccountMarket>;
 };
-declare function getEndRevealPeriodInstruction<TAccountAuthority extends string, TAccountMarket extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: EndRevealPeriodInput<TAccountAuthority, TAccountMarket>, config?: {
+declare function getEndRevealPeriodInstruction<TAccountSigner extends string, TAccountMarket extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: EndRevealPeriodInput<TAccountSigner, TAccountMarket>, config?: {
     programAddress?: TProgramAddress;
-}): EndRevealPeriodInstruction<TProgramAddress, TAccountAuthority, TAccountMarket>;
+}): EndRevealPeriodInstruction<TProgramAddress, TAccountSigner, TAccountMarket>;
 type ParsedEndRevealPeriodInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
-        authority: TAccountMetas[0];
+        signer: TAccountMetas[0];
         market: TAccountMetas[1];
     };
     data: EndRevealPeriodInstructionData;
@@ -2557,170 +2482,56 @@ declare function parseEndRevealPeriodInstruction<TProgram extends string, TAccou
  * @see https://github.com/codama-idl/codama
  */
 
-declare const FINALIZE_NEW_FEE_CLAIMER_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getFinalizeNewFeeClaimerDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type FinalizeNewFeeClaimerInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountUpdateAuthority extends string | AccountMeta<string> = string, TAccountProposedFeeClaimer extends string | AccountMeta<string> = string, TAccountCentralState extends string | AccountMeta<string> = string, TAccountTimelockedChange extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
-    TAccountUpdateAuthority extends string ? WritableSignerAccount<TAccountUpdateAuthority> & AccountSignerMeta<TAccountUpdateAuthority> : TAccountUpdateAuthority,
-    TAccountProposedFeeClaimer extends string ? ReadonlySignerAccount<TAccountProposedFeeClaimer> & AccountSignerMeta<TAccountProposedFeeClaimer> : TAccountProposedFeeClaimer,
-    TAccountCentralState extends string ? WritableAccount<TAccountCentralState> : TAccountCentralState,
-    TAccountTimelockedChange extends string ? WritableAccount<TAccountTimelockedChange> : TAccountTimelockedChange,
-    ...TRemainingAccounts
-]>;
-type FinalizeNewFeeClaimerInstructionData = {
-    discriminator: ReadonlyUint8Array;
-};
-type FinalizeNewFeeClaimerInstructionDataArgs = {};
-declare function getFinalizeNewFeeClaimerInstructionDataEncoder(): FixedSizeEncoder<FinalizeNewFeeClaimerInstructionDataArgs>;
-declare function getFinalizeNewFeeClaimerInstructionDataDecoder(): FixedSizeDecoder<FinalizeNewFeeClaimerInstructionData>;
-declare function getFinalizeNewFeeClaimerInstructionDataCodec(): FixedSizeCodec<FinalizeNewFeeClaimerInstructionDataArgs, FinalizeNewFeeClaimerInstructionData>;
-type FinalizeNewFeeClaimerAsyncInput<TAccountUpdateAuthority extends string = string, TAccountProposedFeeClaimer extends string = string, TAccountCentralState extends string = string, TAccountTimelockedChange extends string = string> = {
-    updateAuthority: TransactionSigner<TAccountUpdateAuthority>;
-    /** The proposed new fee claimer must co-sign to prevent fat-finger mistakes. */
-    proposedFeeClaimer: TransactionSigner<TAccountProposedFeeClaimer>;
-    centralState?: Address<TAccountCentralState>;
-    timelockedChange?: Address<TAccountTimelockedChange>;
-};
-declare function getFinalizeNewFeeClaimerInstructionAsync<TAccountUpdateAuthority extends string, TAccountProposedFeeClaimer extends string, TAccountCentralState extends string, TAccountTimelockedChange extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: FinalizeNewFeeClaimerAsyncInput<TAccountUpdateAuthority, TAccountProposedFeeClaimer, TAccountCentralState, TAccountTimelockedChange>, config?: {
-    programAddress?: TProgramAddress;
-}): Promise<FinalizeNewFeeClaimerInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountProposedFeeClaimer, TAccountCentralState, TAccountTimelockedChange>>;
-type FinalizeNewFeeClaimerInput<TAccountUpdateAuthority extends string = string, TAccountProposedFeeClaimer extends string = string, TAccountCentralState extends string = string, TAccountTimelockedChange extends string = string> = {
-    updateAuthority: TransactionSigner<TAccountUpdateAuthority>;
-    /** The proposed new fee claimer must co-sign to prevent fat-finger mistakes. */
-    proposedFeeClaimer: TransactionSigner<TAccountProposedFeeClaimer>;
-    centralState: Address<TAccountCentralState>;
-    timelockedChange: Address<TAccountTimelockedChange>;
-};
-declare function getFinalizeNewFeeClaimerInstruction<TAccountUpdateAuthority extends string, TAccountProposedFeeClaimer extends string, TAccountCentralState extends string, TAccountTimelockedChange extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: FinalizeNewFeeClaimerInput<TAccountUpdateAuthority, TAccountProposedFeeClaimer, TAccountCentralState, TAccountTimelockedChange>, config?: {
-    programAddress?: TProgramAddress;
-}): FinalizeNewFeeClaimerInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountProposedFeeClaimer, TAccountCentralState, TAccountTimelockedChange>;
-type ParsedFinalizeNewFeeClaimerInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
-    programAddress: Address<TProgram>;
-    accounts: {
-        updateAuthority: TAccountMetas[0];
-        /** The proposed new fee claimer must co-sign to prevent fat-finger mistakes. */
-        proposedFeeClaimer: TAccountMetas[1];
-        centralState: TAccountMetas[2];
-        timelockedChange: TAccountMetas[3];
-    };
-    data: FinalizeNewFeeClaimerInstructionData;
-};
-declare function parseFinalizeNewFeeClaimerInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedFinalizeNewFeeClaimerInstruction<TProgram, TAccountMetas>;
-
-/**
- * This code was AUTOGENERATED using the Codama library.
- * Please DO NOT EDIT THIS FILE, instead use visitors
- * to add features, then rerun Codama to update it.
- *
- * @see https://github.com/codama-idl/codama
- */
-
-declare const FINALIZE_NEW_UPDATE_AUTHORITY_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getFinalizeNewUpdateAuthorityDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type FinalizeNewUpdateAuthorityInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountUpdateAuthority extends string | AccountMeta<string> = string, TAccountProposedAuthority extends string | AccountMeta<string> = string, TAccountCentralState extends string | AccountMeta<string> = string, TAccountTimelockedChange extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
-    TAccountUpdateAuthority extends string ? WritableSignerAccount<TAccountUpdateAuthority> & AccountSignerMeta<TAccountUpdateAuthority> : TAccountUpdateAuthority,
-    TAccountProposedAuthority extends string ? ReadonlySignerAccount<TAccountProposedAuthority> & AccountSignerMeta<TAccountProposedAuthority> : TAccountProposedAuthority,
-    TAccountCentralState extends string ? WritableAccount<TAccountCentralState> : TAccountCentralState,
-    TAccountTimelockedChange extends string ? WritableAccount<TAccountTimelockedChange> : TAccountTimelockedChange,
-    ...TRemainingAccounts
-]>;
-type FinalizeNewUpdateAuthorityInstructionData = {
-    discriminator: ReadonlyUint8Array;
-};
-type FinalizeNewUpdateAuthorityInstructionDataArgs = {};
-declare function getFinalizeNewUpdateAuthorityInstructionDataEncoder(): FixedSizeEncoder<FinalizeNewUpdateAuthorityInstructionDataArgs>;
-declare function getFinalizeNewUpdateAuthorityInstructionDataDecoder(): FixedSizeDecoder<FinalizeNewUpdateAuthorityInstructionData>;
-declare function getFinalizeNewUpdateAuthorityInstructionDataCodec(): FixedSizeCodec<FinalizeNewUpdateAuthorityInstructionDataArgs, FinalizeNewUpdateAuthorityInstructionData>;
-type FinalizeNewUpdateAuthorityAsyncInput<TAccountUpdateAuthority extends string = string, TAccountProposedAuthority extends string = string, TAccountCentralState extends string = string, TAccountTimelockedChange extends string = string> = {
-    updateAuthority: TransactionSigner<TAccountUpdateAuthority>;
-    /** The proposed new authority must co-sign to prevent fat-finger mistakes. */
-    proposedAuthority: TransactionSigner<TAccountProposedAuthority>;
-    centralState?: Address<TAccountCentralState>;
-    timelockedChange?: Address<TAccountTimelockedChange>;
-};
-declare function getFinalizeNewUpdateAuthorityInstructionAsync<TAccountUpdateAuthority extends string, TAccountProposedAuthority extends string, TAccountCentralState extends string, TAccountTimelockedChange extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: FinalizeNewUpdateAuthorityAsyncInput<TAccountUpdateAuthority, TAccountProposedAuthority, TAccountCentralState, TAccountTimelockedChange>, config?: {
-    programAddress?: TProgramAddress;
-}): Promise<FinalizeNewUpdateAuthorityInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountProposedAuthority, TAccountCentralState, TAccountTimelockedChange>>;
-type FinalizeNewUpdateAuthorityInput<TAccountUpdateAuthority extends string = string, TAccountProposedAuthority extends string = string, TAccountCentralState extends string = string, TAccountTimelockedChange extends string = string> = {
-    updateAuthority: TransactionSigner<TAccountUpdateAuthority>;
-    /** The proposed new authority must co-sign to prevent fat-finger mistakes. */
-    proposedAuthority: TransactionSigner<TAccountProposedAuthority>;
-    centralState: Address<TAccountCentralState>;
-    timelockedChange: Address<TAccountTimelockedChange>;
-};
-declare function getFinalizeNewUpdateAuthorityInstruction<TAccountUpdateAuthority extends string, TAccountProposedAuthority extends string, TAccountCentralState extends string, TAccountTimelockedChange extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: FinalizeNewUpdateAuthorityInput<TAccountUpdateAuthority, TAccountProposedAuthority, TAccountCentralState, TAccountTimelockedChange>, config?: {
-    programAddress?: TProgramAddress;
-}): FinalizeNewUpdateAuthorityInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountProposedAuthority, TAccountCentralState, TAccountTimelockedChange>;
-type ParsedFinalizeNewUpdateAuthorityInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
-    programAddress: Address<TProgram>;
-    accounts: {
-        updateAuthority: TAccountMetas[0];
-        /** The proposed new authority must co-sign to prevent fat-finger mistakes. */
-        proposedAuthority: TAccountMetas[1];
-        centralState: TAccountMetas[2];
-        timelockedChange: TAccountMetas[3];
-    };
-    data: FinalizeNewUpdateAuthorityInstructionData;
-};
-declare function parseFinalizeNewUpdateAuthorityInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedFinalizeNewUpdateAuthorityInstruction<TProgram, TAccountMetas>;
-
-/**
- * This code was AUTOGENERATED using the Codama library.
- * Please DO NOT EDIT THIS FILE, instead use visitors
- * to add features, then rerun Codama to update it.
- *
- * @see https://github.com/codama-idl/codama
- */
-
-declare const INCREMENT_OPTION_TALLY_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getIncrementOptionTallyDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type IncrementOptionTallyInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TAccountOwner extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountStakeAccount extends string | AccountMeta<string> = string, TAccountOption extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+declare const FINALIZE_REVEAL_STAKE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getFinalizeRevealStakeDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type FinalizeRevealStakeInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TAccountOwner extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountStakeAccount extends string | AccountMeta<string> = string, TAccountOption extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
     TAccountSigner extends string ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
     TAccountOwner extends string ? ReadonlyAccount<TAccountOwner> : TAccountOwner,
-    TAccountMarket extends string ? ReadonlyAccount<TAccountMarket> : TAccountMarket,
+    TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
     TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
     TAccountOption extends string ? WritableAccount<TAccountOption> : TAccountOption,
     TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
     ...TRemainingAccounts
 ]>;
-type IncrementOptionTallyInstructionData = {
+type FinalizeRevealStakeInstructionData = {
     discriminator: ReadonlyUint8Array;
     optionId: bigint;
     stakeAccountId: number;
 };
-type IncrementOptionTallyInstructionDataArgs = {
+type FinalizeRevealStakeInstructionDataArgs = {
     optionId: number | bigint;
     stakeAccountId: number;
 };
-declare function getIncrementOptionTallyInstructionDataEncoder(): FixedSizeEncoder<IncrementOptionTallyInstructionDataArgs>;
-declare function getIncrementOptionTallyInstructionDataDecoder(): FixedSizeDecoder<IncrementOptionTallyInstructionData>;
-declare function getIncrementOptionTallyInstructionDataCodec(): FixedSizeCodec<IncrementOptionTallyInstructionDataArgs, IncrementOptionTallyInstructionData>;
-type IncrementOptionTallyAsyncInput<TAccountSigner extends string = string, TAccountOwner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountOption extends string = string, TAccountSystemProgram extends string = string> = {
+declare function getFinalizeRevealStakeInstructionDataEncoder(): FixedSizeEncoder<FinalizeRevealStakeInstructionDataArgs>;
+declare function getFinalizeRevealStakeInstructionDataDecoder(): FixedSizeDecoder<FinalizeRevealStakeInstructionData>;
+declare function getFinalizeRevealStakeInstructionDataCodec(): FixedSizeCodec<FinalizeRevealStakeInstructionDataArgs, FinalizeRevealStakeInstructionData>;
+type FinalizeRevealStakeAsyncInput<TAccountSigner extends string = string, TAccountOwner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountOption extends string = string, TAccountSystemProgram extends string = string> = {
     signer: TransactionSigner<TAccountSigner>;
     owner: Address<TAccountOwner>;
     market: Address<TAccountMarket>;
     stakeAccount?: Address<TAccountStakeAccount>;
     option?: Address<TAccountOption>;
     systemProgram?: Address<TAccountSystemProgram>;
-    optionId: IncrementOptionTallyInstructionDataArgs['optionId'];
-    stakeAccountId: IncrementOptionTallyInstructionDataArgs['stakeAccountId'];
+    optionId: FinalizeRevealStakeInstructionDataArgs['optionId'];
+    stakeAccountId: FinalizeRevealStakeInstructionDataArgs['stakeAccountId'];
 };
-declare function getIncrementOptionTallyInstructionAsync<TAccountSigner extends string, TAccountOwner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountOption extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: IncrementOptionTallyAsyncInput<TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountOption, TAccountSystemProgram>, config?: {
+declare function getFinalizeRevealStakeInstructionAsync<TAccountSigner extends string, TAccountOwner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountOption extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: FinalizeRevealStakeAsyncInput<TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountOption, TAccountSystemProgram>, config?: {
     programAddress?: TProgramAddress;
-}): Promise<IncrementOptionTallyInstruction<TProgramAddress, TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountOption, TAccountSystemProgram>>;
-type IncrementOptionTallyInput<TAccountSigner extends string = string, TAccountOwner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountOption extends string = string, TAccountSystemProgram extends string = string> = {
+}): Promise<FinalizeRevealStakeInstruction<TProgramAddress, TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountOption, TAccountSystemProgram>>;
+type FinalizeRevealStakeInput<TAccountSigner extends string = string, TAccountOwner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountOption extends string = string, TAccountSystemProgram extends string = string> = {
     signer: TransactionSigner<TAccountSigner>;
     owner: Address<TAccountOwner>;
     market: Address<TAccountMarket>;
     stakeAccount: Address<TAccountStakeAccount>;
     option: Address<TAccountOption>;
     systemProgram?: Address<TAccountSystemProgram>;
-    optionId: IncrementOptionTallyInstructionDataArgs['optionId'];
-    stakeAccountId: IncrementOptionTallyInstructionDataArgs['stakeAccountId'];
+    optionId: FinalizeRevealStakeInstructionDataArgs['optionId'];
+    stakeAccountId: FinalizeRevealStakeInstructionDataArgs['stakeAccountId'];
 };
-declare function getIncrementOptionTallyInstruction<TAccountSigner extends string, TAccountOwner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountOption extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: IncrementOptionTallyInput<TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountOption, TAccountSystemProgram>, config?: {
+declare function getFinalizeRevealStakeInstruction<TAccountSigner extends string, TAccountOwner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountOption extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: FinalizeRevealStakeInput<TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountOption, TAccountSystemProgram>, config?: {
     programAddress?: TProgramAddress;
-}): IncrementOptionTallyInstruction<TProgramAddress, TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountOption, TAccountSystemProgram>;
-type ParsedIncrementOptionTallyInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+}): FinalizeRevealStakeInstruction<TProgramAddress, TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountOption, TAccountSystemProgram>;
+type ParsedFinalizeRevealStakeInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
         signer: TAccountMetas[0];
@@ -2730,68 +2541,9 @@ type ParsedIncrementOptionTallyInstruction<TProgram extends string = typeof OPPO
         option: TAccountMetas[4];
         systemProgram: TAccountMetas[5];
     };
-    data: IncrementOptionTallyInstructionData;
-};
-declare function parseIncrementOptionTallyInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedIncrementOptionTallyInstruction<TProgram, TAccountMetas>;
-
-/**
- * This code was AUTOGENERATED using the Codama library.
- * Please DO NOT EDIT THIS FILE, instead use visitors
- * to add features, then rerun Codama to update it.
- *
- * @see https://github.com/codama-idl/codama
- */
-
-declare const INIT_CENTRAL_STATE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getInitCentralStateDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type InitCentralStateInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountPayer extends string | AccountMeta<string> = string, TAccountCentralState extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
-    TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer,
-    TAccountCentralState extends string ? WritableAccount<TAccountCentralState> : TAccountCentralState,
-    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
-    ...TRemainingAccounts
-]>;
-type InitCentralStateInstructionData = {
-    discriminator: ReadonlyUint8Array;
-    protocolFeeBp: number;
-    feeClaimer: Address;
-};
-type InitCentralStateInstructionDataArgs = {
-    protocolFeeBp: number;
-    feeClaimer: Address;
-};
-declare function getInitCentralStateInstructionDataEncoder(): FixedSizeEncoder<InitCentralStateInstructionDataArgs>;
-declare function getInitCentralStateInstructionDataDecoder(): FixedSizeDecoder<InitCentralStateInstructionData>;
-declare function getInitCentralStateInstructionDataCodec(): FixedSizeCodec<InitCentralStateInstructionDataArgs, InitCentralStateInstructionData>;
-type InitCentralStateAsyncInput<TAccountPayer extends string = string, TAccountCentralState extends string = string, TAccountSystemProgram extends string = string> = {
-    payer: TransactionSigner<TAccountPayer>;
-    centralState?: Address<TAccountCentralState>;
-    systemProgram?: Address<TAccountSystemProgram>;
-    protocolFeeBp: InitCentralStateInstructionDataArgs['protocolFeeBp'];
-    feeClaimer: InitCentralStateInstructionDataArgs['feeClaimer'];
-};
-declare function getInitCentralStateInstructionAsync<TAccountPayer extends string, TAccountCentralState extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: InitCentralStateAsyncInput<TAccountPayer, TAccountCentralState, TAccountSystemProgram>, config?: {
-    programAddress?: TProgramAddress;
-}): Promise<InitCentralStateInstruction<TProgramAddress, TAccountPayer, TAccountCentralState, TAccountSystemProgram>>;
-type InitCentralStateInput<TAccountPayer extends string = string, TAccountCentralState extends string = string, TAccountSystemProgram extends string = string> = {
-    payer: TransactionSigner<TAccountPayer>;
-    centralState: Address<TAccountCentralState>;
-    systemProgram?: Address<TAccountSystemProgram>;
-    protocolFeeBp: InitCentralStateInstructionDataArgs['protocolFeeBp'];
-    feeClaimer: InitCentralStateInstructionDataArgs['feeClaimer'];
-};
-declare function getInitCentralStateInstruction<TAccountPayer extends string, TAccountCentralState extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: InitCentralStateInput<TAccountPayer, TAccountCentralState, TAccountSystemProgram>, config?: {
-    programAddress?: TProgramAddress;
-}): InitCentralStateInstruction<TProgramAddress, TAccountPayer, TAccountCentralState, TAccountSystemProgram>;
-type ParsedInitCentralStateInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
-    programAddress: Address<TProgram>;
-    accounts: {
-        payer: TAccountMetas[0];
-        centralState: TAccountMetas[1];
-        systemProgram: TAccountMetas[2];
-    };
-    data: InitCentralStateInstructionData;
+    data: FinalizeRevealStakeInstructionData;
 };
-declare function parseInitCentralStateInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedInitCentralStateInstruction<TProgram, TAccountMetas>;
+declare function parseFinalizeRevealStakeInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedFinalizeRevealStakeInstruction<TProgram, TAccountMetas>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -2801,60 +2553,55 @@ declare function parseInitCentralStateInstruction<TProgram extends string, TAcco
  * @see https://github.com/codama-idl/codama
  */
 
-declare const INIT_STAKE_ACCOUNT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getInitStakeAccountDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type InitStakeAccountInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountStakeAccount extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
-    TAccountSigner extends string ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
-    TAccountMarket extends string ? ReadonlyAccount<TAccountMarket> : TAccountMarket,
-    TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
+declare const INIT_ALLOWED_MINT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getInitAllowedMintDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type InitAllowedMintInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountUpdateAuthority extends string | AccountMeta<string> = string, TAccountPlatformConfig extends string | AccountMeta<string> = string, TAccountTokenMint extends string | AccountMeta<string> = string, TAccountAllowedMint extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountUpdateAuthority extends string ? WritableSignerAccount<TAccountUpdateAuthority> & AccountSignerMeta<TAccountUpdateAuthority> : TAccountUpdateAuthority,
+    TAccountPlatformConfig extends string ? ReadonlyAccount<TAccountPlatformConfig> : TAccountPlatformConfig,
+    TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
+    TAccountAllowedMint extends string ? WritableAccount<TAccountAllowedMint> : TAccountAllowedMint,
     TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
     ...TRemainingAccounts
 ]>;
-type InitStakeAccountInstructionData = {
+type InitAllowedMintInstructionData = {
     discriminator: ReadonlyUint8Array;
-    stateNonce: bigint;
-    stakeAccountId: number;
-};
-type InitStakeAccountInstructionDataArgs = {
-    stateNonce: number | bigint;
-    stakeAccountId: number;
 };
-declare function getInitStakeAccountInstructionDataEncoder(): FixedSizeEncoder<InitStakeAccountInstructionDataArgs>;
-declare function getInitStakeAccountInstructionDataDecoder(): FixedSizeDecoder<InitStakeAccountInstructionData>;
-declare function getInitStakeAccountInstructionDataCodec(): FixedSizeCodec<InitStakeAccountInstructionDataArgs, InitStakeAccountInstructionData>;
-type InitStakeAccountAsyncInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountSystemProgram extends string = string> = {
-    signer: TransactionSigner<TAccountSigner>;
-    market: Address<TAccountMarket>;
-    stakeAccount?: Address<TAccountStakeAccount>;
+type InitAllowedMintInstructionDataArgs = {};
+declare function getInitAllowedMintInstructionDataEncoder(): FixedSizeEncoder<InitAllowedMintInstructionDataArgs>;
+declare function getInitAllowedMintInstructionDataDecoder(): FixedSizeDecoder<InitAllowedMintInstructionData>;
+declare function getInitAllowedMintInstructionDataCodec(): FixedSizeCodec<InitAllowedMintInstructionDataArgs, InitAllowedMintInstructionData>;
+type InitAllowedMintAsyncInput<TAccountUpdateAuthority extends string = string, TAccountPlatformConfig extends string = string, TAccountTokenMint extends string = string, TAccountAllowedMint extends string = string, TAccountSystemProgram extends string = string> = {
+    updateAuthority: TransactionSigner<TAccountUpdateAuthority>;
+    platformConfig: Address<TAccountPlatformConfig>;
+    tokenMint: Address<TAccountTokenMint>;
+    allowedMint?: Address<TAccountAllowedMint>;
     systemProgram?: Address<TAccountSystemProgram>;
-    stateNonce: InitStakeAccountInstructionDataArgs['stateNonce'];
-    stakeAccountId: InitStakeAccountInstructionDataArgs['stakeAccountId'];
 };
-declare function getInitStakeAccountInstructionAsync<TAccountSigner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: InitStakeAccountAsyncInput<TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountSystemProgram>, config?: {
+declare function getInitAllowedMintInstructionAsync<TAccountUpdateAuthority extends string, TAccountPlatformConfig extends string, TAccountTokenMint extends string, TAccountAllowedMint extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: InitAllowedMintAsyncInput<TAccountUpdateAuthority, TAccountPlatformConfig, TAccountTokenMint, TAccountAllowedMint, TAccountSystemProgram>, config?: {
     programAddress?: TProgramAddress;
-}): Promise<InitStakeAccountInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountSystemProgram>>;
-type InitStakeAccountInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountSystemProgram extends string = string> = {
-    signer: TransactionSigner<TAccountSigner>;
-    market: Address<TAccountMarket>;
-    stakeAccount: Address<TAccountStakeAccount>;
+}): Promise<InitAllowedMintInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountPlatformConfig, TAccountTokenMint, TAccountAllowedMint, TAccountSystemProgram>>;
+type InitAllowedMintInput<TAccountUpdateAuthority extends string = string, TAccountPlatformConfig extends string = string, TAccountTokenMint extends string = string, TAccountAllowedMint extends string = string, TAccountSystemProgram extends string = string> = {
+    updateAuthority: TransactionSigner<TAccountUpdateAuthority>;
+    platformConfig: Address<TAccountPlatformConfig>;
+    tokenMint: Address<TAccountTokenMint>;
+    allowedMint: Address<TAccountAllowedMint>;
     systemProgram?: Address<TAccountSystemProgram>;
-    stateNonce: InitStakeAccountInstructionDataArgs['stateNonce'];
-    stakeAccountId: InitStakeAccountInstructionDataArgs['stakeAccountId'];
 };
-declare function getInitStakeAccountInstruction<TAccountSigner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: InitStakeAccountInput<TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountSystemProgram>, config?: {
+declare function getInitAllowedMintInstruction<TAccountUpdateAuthority extends string, TAccountPlatformConfig extends string, TAccountTokenMint extends string, TAccountAllowedMint extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: InitAllowedMintInput<TAccountUpdateAuthority, TAccountPlatformConfig, TAccountTokenMint, TAccountAllowedMint, TAccountSystemProgram>, config?: {
     programAddress?: TProgramAddress;
-}): InitStakeAccountInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountSystemProgram>;
-type ParsedInitStakeAccountInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+}): InitAllowedMintInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountPlatformConfig, TAccountTokenMint, TAccountAllowedMint, TAccountSystemProgram>;
+type ParsedInitAllowedMintInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
-        signer: TAccountMetas[0];
-        market: TAccountMetas[1];
-        stakeAccount: TAccountMetas[2];
-        systemProgram: TAccountMetas[3];
+        updateAuthority: TAccountMetas[0];
+        platformConfig: TAccountMetas[1];
+        tokenMint: TAccountMetas[2];
+        allowedMint: TAccountMetas[3];
+        systemProgram: TAccountMetas[4];
     };
-    data: InitStakeAccountInstructionData;
+    data: InitAllowedMintInstructionData;
 };
-declare function parseInitStakeAccountInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedInitStakeAccountInstruction<TProgram, TAccountMetas>;
+declare function parseInitAllowedMintInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedInitAllowedMintInstruction<TProgram, TAccountMetas>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -2864,51 +2611,84 @@ declare function parseInitStakeAccountInstruction<TProgram extends string, TAcco
  * @see https://github.com/codama-idl/codama
  */
 
-declare const INIT_TOKEN_VAULT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getInitTokenVaultDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type InitTokenVaultInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountPayer extends string | AccountMeta<string> = string, TAccountTokenMint extends string | AccountMeta<string> = string, TAccountTokenVault extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+declare const INIT_PLATFORM_CONFIG_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getInitPlatformConfigDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type InitPlatformConfigInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountPayer extends string | AccountMeta<string> = string, TAccountPlatformConfig extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
     TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer,
-    TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
-    TAccountTokenVault extends string ? WritableAccount<TAccountTokenVault> : TAccountTokenVault,
+    TAccountPlatformConfig extends string ? WritableAccount<TAccountPlatformConfig> : TAccountPlatformConfig,
     TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
     ...TRemainingAccounts
 ]>;
-type InitTokenVaultInstructionData = {
+type InitPlatformConfigInstructionData = {
     discriminator: ReadonlyUint8Array;
-};
-type InitTokenVaultInstructionDataArgs = {};
-declare function getInitTokenVaultInstructionDataEncoder(): FixedSizeEncoder<InitTokenVaultInstructionDataArgs>;
-declare function getInitTokenVaultInstructionDataDecoder(): FixedSizeDecoder<InitTokenVaultInstructionData>;
-declare function getInitTokenVaultInstructionDataCodec(): FixedSizeCodec<InitTokenVaultInstructionDataArgs, InitTokenVaultInstructionData>;
-type InitTokenVaultAsyncInput<TAccountPayer extends string = string, TAccountTokenMint extends string = string, TAccountTokenVault extends string = string, TAccountSystemProgram extends string = string> = {
+    name: string;
+    platformFeeBp: number;
+    rewardPoolFeeBp: number;
+    creatorFeeBp: number;
+    feeClaimAuthority: Address;
+    minTimeToStakeSeconds: bigint;
+    minRevealPeriodSeconds: bigint;
+    maxRevealPeriodSeconds: bigint;
+    marketResolutionDeadlineSeconds: bigint;
+};
+type InitPlatformConfigInstructionDataArgs = {
+    name: string;
+    platformFeeBp: number;
+    rewardPoolFeeBp: number;
+    creatorFeeBp: number;
+    feeClaimAuthority: Address;
+    minTimeToStakeSeconds: number | bigint;
+    minRevealPeriodSeconds: number | bigint;
+    maxRevealPeriodSeconds: number | bigint;
+    marketResolutionDeadlineSeconds: number | bigint;
+};
+declare function getInitPlatformConfigInstructionDataEncoder(): Encoder<InitPlatformConfigInstructionDataArgs>;
+declare function getInitPlatformConfigInstructionDataDecoder(): Decoder<InitPlatformConfigInstructionData>;
+declare function getInitPlatformConfigInstructionDataCodec(): Codec<InitPlatformConfigInstructionDataArgs, InitPlatformConfigInstructionData>;
+type InitPlatformConfigAsyncInput<TAccountPayer extends string = string, TAccountPlatformConfig extends string = string, TAccountSystemProgram extends string = string> = {
     payer: TransactionSigner<TAccountPayer>;
-    tokenMint: Address<TAccountTokenMint>;
-    tokenVault?: Address<TAccountTokenVault>;
+    platformConfig?: Address<TAccountPlatformConfig>;
     systemProgram?: Address<TAccountSystemProgram>;
-};
-declare function getInitTokenVaultInstructionAsync<TAccountPayer extends string, TAccountTokenMint extends string, TAccountTokenVault extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: InitTokenVaultAsyncInput<TAccountPayer, TAccountTokenMint, TAccountTokenVault, TAccountSystemProgram>, config?: {
+    name: InitPlatformConfigInstructionDataArgs['name'];
+    platformFeeBp: InitPlatformConfigInstructionDataArgs['platformFeeBp'];
+    rewardPoolFeeBp: InitPlatformConfigInstructionDataArgs['rewardPoolFeeBp'];
+    creatorFeeBp: InitPlatformConfigInstructionDataArgs['creatorFeeBp'];
+    feeClaimAuthority: InitPlatformConfigInstructionDataArgs['feeClaimAuthority'];
+    minTimeToStakeSeconds: InitPlatformConfigInstructionDataArgs['minTimeToStakeSeconds'];
+    minRevealPeriodSeconds: InitPlatformConfigInstructionDataArgs['minRevealPeriodSeconds'];
+    maxRevealPeriodSeconds: InitPlatformConfigInstructionDataArgs['maxRevealPeriodSeconds'];
+    marketResolutionDeadlineSeconds: InitPlatformConfigInstructionDataArgs['marketResolutionDeadlineSeconds'];
+};
+declare function getInitPlatformConfigInstructionAsync<TAccountPayer extends string, TAccountPlatformConfig extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: InitPlatformConfigAsyncInput<TAccountPayer, TAccountPlatformConfig, TAccountSystemProgram>, config?: {
     programAddress?: TProgramAddress;
-}): Promise<InitTokenVaultInstruction<TProgramAddress, TAccountPayer, TAccountTokenMint, TAccountTokenVault, TAccountSystemProgram>>;
-type InitTokenVaultInput<TAccountPayer extends string = string, TAccountTokenMint extends string = string, TAccountTokenVault extends string = string, TAccountSystemProgram extends string = string> = {
+}): Promise<InitPlatformConfigInstruction<TProgramAddress, TAccountPayer, TAccountPlatformConfig, TAccountSystemProgram>>;
+type InitPlatformConfigInput<TAccountPayer extends string = string, TAccountPlatformConfig extends string = string, TAccountSystemProgram extends string = string> = {
     payer: TransactionSigner<TAccountPayer>;
-    tokenMint: Address<TAccountTokenMint>;
-    tokenVault: Address<TAccountTokenVault>;
+    platformConfig: Address<TAccountPlatformConfig>;
     systemProgram?: Address<TAccountSystemProgram>;
-};
-declare function getInitTokenVaultInstruction<TAccountPayer extends string, TAccountTokenMint extends string, TAccountTokenVault extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: InitTokenVaultInput<TAccountPayer, TAccountTokenMint, TAccountTokenVault, TAccountSystemProgram>, config?: {
+    name: InitPlatformConfigInstructionDataArgs['name'];
+    platformFeeBp: InitPlatformConfigInstructionDataArgs['platformFeeBp'];
+    rewardPoolFeeBp: InitPlatformConfigInstructionDataArgs['rewardPoolFeeBp'];
+    creatorFeeBp: InitPlatformConfigInstructionDataArgs['creatorFeeBp'];
+    feeClaimAuthority: InitPlatformConfigInstructionDataArgs['feeClaimAuthority'];
+    minTimeToStakeSeconds: InitPlatformConfigInstructionDataArgs['minTimeToStakeSeconds'];
+    minRevealPeriodSeconds: InitPlatformConfigInstructionDataArgs['minRevealPeriodSeconds'];
+    maxRevealPeriodSeconds: InitPlatformConfigInstructionDataArgs['maxRevealPeriodSeconds'];
+    marketResolutionDeadlineSeconds: InitPlatformConfigInstructionDataArgs['marketResolutionDeadlineSeconds'];
+};
+declare function getInitPlatformConfigInstruction<TAccountPayer extends string, TAccountPlatformConfig extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: InitPlatformConfigInput<TAccountPayer, TAccountPlatformConfig, TAccountSystemProgram>, config?: {
     programAddress?: TProgramAddress;
-}): InitTokenVaultInstruction<TProgramAddress, TAccountPayer, TAccountTokenMint, TAccountTokenVault, TAccountSystemProgram>;
-type ParsedInitTokenVaultInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+}): InitPlatformConfigInstruction<TProgramAddress, TAccountPayer, TAccountPlatformConfig, TAccountSystemProgram>;
+type ParsedInitPlatformConfigInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
         payer: TAccountMetas[0];
-        tokenMint: TAccountMetas[1];
-        tokenVault: TAccountMetas[2];
-        systemProgram: TAccountMetas[3];
+        platformConfig: TAccountMetas[1];
+        systemProgram: TAccountMetas[2];
     };
-    data: InitTokenVaultInstructionData;
+    data: InitPlatformConfigInstructionData;
 };
-declare function parseInitTokenVaultInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedInitTokenVaultInstruction<TProgram, TAccountMetas>;
+declare function parseInitPlatformConfigInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedInitPlatformConfigInstruction<TProgram, TAccountMetas>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -2918,79 +2698,63 @@ declare function parseInitTokenVaultInstruction<TProgram extends string, TAccoun
  * @see https://github.com/codama-idl/codama
  */
 
-declare const OPEN_MARKET_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getOpenMarketDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type OpenMarketInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountCreator extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
-    TAccountCreator extends string ? ReadonlySignerAccount<TAccountCreator> & AccountSignerMeta<TAccountCreator> : TAccountCreator,
-    TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
+declare const INIT_STAKE_ACCOUNT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getInitStakeAccountDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type InitStakeAccountInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountPayer extends string | AccountMeta<string> = string, TAccountOwner extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountStakeAccount extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer,
+    TAccountOwner extends string ? ReadonlyAccount<TAccountOwner> : TAccountOwner,
+    TAccountMarket extends string ? ReadonlyAccount<TAccountMarket> : TAccountMarket,
+    TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
+    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
     ...TRemainingAccounts
 ]>;
-type OpenMarketInstructionData = {
+type InitStakeAccountInstructionData = {
     discriminator: ReadonlyUint8Array;
-    openTimestamp: bigint;
+    stakeAccountId: number;
 };
-type OpenMarketInstructionDataArgs = {
-    openTimestamp: number | bigint;
+type InitStakeAccountInstructionDataArgs = {
+    stakeAccountId: number;
 };
-declare function getOpenMarketInstructionDataEncoder(): FixedSizeEncoder<OpenMarketInstructionDataArgs>;
-declare function getOpenMarketInstructionDataDecoder(): FixedSizeDecoder<OpenMarketInstructionData>;
-declare function getOpenMarketInstructionDataCodec(): FixedSizeCodec<OpenMarketInstructionDataArgs, OpenMarketInstructionData>;
-type OpenMarketInput<TAccountCreator extends string = string, TAccountMarket extends string = string> = {
-    creator: TransactionSigner<TAccountCreator>;
+declare function getInitStakeAccountInstructionDataEncoder(): FixedSizeEncoder<InitStakeAccountInstructionDataArgs>;
+declare function getInitStakeAccountInstructionDataDecoder(): FixedSizeDecoder<InitStakeAccountInstructionData>;
+declare function getInitStakeAccountInstructionDataCodec(): FixedSizeCodec<InitStakeAccountInstructionDataArgs, InitStakeAccountInstructionData>;
+type InitStakeAccountAsyncInput<TAccountPayer extends string = string, TAccountOwner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountSystemProgram extends string = string> = {
+    payer: TransactionSigner<TAccountPayer>;
+    /** No signature required: this instruction is permissionless. */
+    owner: Address<TAccountOwner>;
     market: Address<TAccountMarket>;
-    openTimestamp: OpenMarketInstructionDataArgs['openTimestamp'];
-};
-declare function getOpenMarketInstruction<TAccountCreator extends string, TAccountMarket extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: OpenMarketInput<TAccountCreator, TAccountMarket>, config?: {
-    programAddress?: TProgramAddress;
-}): OpenMarketInstruction<TProgramAddress, TAccountCreator, TAccountMarket>;
-type ParsedOpenMarketInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
-    programAddress: Address<TProgram>;
-    accounts: {
-        creator: TAccountMetas[0];
-        market: TAccountMetas[1];
-    };
-    data: OpenMarketInstructionData;
-};
-declare function parseOpenMarketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedOpenMarketInstruction<TProgram, TAccountMetas>;
-
-/**
- * This code was AUTOGENERATED using the Codama library.
- * Please DO NOT EDIT THIS FILE, instead use visitors
- * to add features, then rerun Codama to update it.
- *
- * @see https://github.com/codama-idl/codama
- */
-
-declare const PAUSE_MARKET_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getPauseMarketDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type PauseMarketInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountAuthority extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
-    TAccountAuthority extends string ? ReadonlySignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority> : TAccountAuthority,
-    TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
-    ...TRemainingAccounts
-]>;
-type PauseMarketInstructionData = {
-    discriminator: ReadonlyUint8Array;
+    stakeAccount?: Address<TAccountStakeAccount>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    stakeAccountId: InitStakeAccountInstructionDataArgs['stakeAccountId'];
 };
-type PauseMarketInstructionDataArgs = {};
-declare function getPauseMarketInstructionDataEncoder(): FixedSizeEncoder<PauseMarketInstructionDataArgs>;
-declare function getPauseMarketInstructionDataDecoder(): FixedSizeDecoder<PauseMarketInstructionData>;
-declare function getPauseMarketInstructionDataCodec(): FixedSizeCodec<PauseMarketInstructionDataArgs, PauseMarketInstructionData>;
-type PauseMarketInput<TAccountAuthority extends string = string, TAccountMarket extends string = string> = {
-    authority: TransactionSigner<TAccountAuthority>;
+declare function getInitStakeAccountInstructionAsync<TAccountPayer extends string, TAccountOwner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: InitStakeAccountAsyncInput<TAccountPayer, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): Promise<InitStakeAccountInstruction<TProgramAddress, TAccountPayer, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountSystemProgram>>;
+type InitStakeAccountInput<TAccountPayer extends string = string, TAccountOwner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountSystemProgram extends string = string> = {
+    payer: TransactionSigner<TAccountPayer>;
+    /** No signature required: this instruction is permissionless. */
+    owner: Address<TAccountOwner>;
     market: Address<TAccountMarket>;
+    stakeAccount: Address<TAccountStakeAccount>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    stakeAccountId: InitStakeAccountInstructionDataArgs['stakeAccountId'];
 };
-declare function getPauseMarketInstruction<TAccountAuthority extends string, TAccountMarket extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: PauseMarketInput<TAccountAuthority, TAccountMarket>, config?: {
+declare function getInitStakeAccountInstruction<TAccountPayer extends string, TAccountOwner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: InitStakeAccountInput<TAccountPayer, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountSystemProgram>, config?: {
     programAddress?: TProgramAddress;
-}): PauseMarketInstruction<TProgramAddress, TAccountAuthority, TAccountMarket>;
-type ParsedPauseMarketInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+}): InitStakeAccountInstruction<TProgramAddress, TAccountPayer, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountSystemProgram>;
+type ParsedInitStakeAccountInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
-        authority: TAccountMetas[0];
-        market: TAccountMetas[1];
+        payer: TAccountMetas[0];
+        /** No signature required: this instruction is permissionless. */
+        owner: TAccountMetas[1];
+        market: TAccountMetas[2];
+        stakeAccount: TAccountMetas[3];
+        systemProgram: TAccountMetas[4];
     };
-    data: PauseMarketInstructionData;
+    data: InitStakeAccountInstructionData;
 };
-declare function parsePauseMarketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedPauseMarketInstruction<TProgram, TAccountMetas>;
+declare function parseInitStakeAccountInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedInitStakeAccountInstruction<TProgram, TAccountMetas>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -3000,55 +2764,43 @@ declare function parsePauseMarketInstruction<TProgram extends string, TAccountMe
  * @see https://github.com/codama-idl/codama
  */
 
-declare const PROPOSE_NEW_FEE_CLAIMER_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getProposeNewFeeClaimerDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type ProposeNewFeeClaimerInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountUpdateAuthority extends string | AccountMeta<string> = string, TAccountCentralState extends string | AccountMeta<string> = string, TAccountProposedFeeClaimer extends string | AccountMeta<string> = string, TAccountTimelockedChange extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
-    TAccountUpdateAuthority extends string ? WritableSignerAccount<TAccountUpdateAuthority> & AccountSignerMeta<TAccountUpdateAuthority> : TAccountUpdateAuthority,
-    TAccountCentralState extends string ? ReadonlyAccount<TAccountCentralState> : TAccountCentralState,
-    TAccountProposedFeeClaimer extends string ? ReadonlyAccount<TAccountProposedFeeClaimer> : TAccountProposedFeeClaimer,
-    TAccountTimelockedChange extends string ? WritableAccount<TAccountTimelockedChange> : TAccountTimelockedChange,
-    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
+declare const OPEN_MARKET_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getOpenMarketDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type OpenMarketInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMarketAuthority extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountPlatformConfig extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountMarketAuthority extends string ? ReadonlySignerAccount<TAccountMarketAuthority> & AccountSignerMeta<TAccountMarketAuthority> : TAccountMarketAuthority,
+    TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
+    TAccountPlatformConfig extends string ? ReadonlyAccount<TAccountPlatformConfig> : TAccountPlatformConfig,
     ...TRemainingAccounts
 ]>;
-type ProposeNewFeeClaimerInstructionData = {
+type OpenMarketInstructionData = {
     discriminator: ReadonlyUint8Array;
+    timeToStake: bigint;
 };
-type ProposeNewFeeClaimerInstructionDataArgs = {};
-declare function getProposeNewFeeClaimerInstructionDataEncoder(): FixedSizeEncoder<ProposeNewFeeClaimerInstructionDataArgs>;
-declare function getProposeNewFeeClaimerInstructionDataDecoder(): FixedSizeDecoder<ProposeNewFeeClaimerInstructionData>;
-declare function getProposeNewFeeClaimerInstructionDataCodec(): FixedSizeCodec<ProposeNewFeeClaimerInstructionDataArgs, ProposeNewFeeClaimerInstructionData>;
-type ProposeNewFeeClaimerAsyncInput<TAccountUpdateAuthority extends string = string, TAccountCentralState extends string = string, TAccountProposedFeeClaimer extends string = string, TAccountTimelockedChange extends string = string, TAccountSystemProgram extends string = string> = {
-    updateAuthority: TransactionSigner<TAccountUpdateAuthority>;
-    centralState?: Address<TAccountCentralState>;
-    proposedFeeClaimer: Address<TAccountProposedFeeClaimer>;
-    timelockedChange?: Address<TAccountTimelockedChange>;
-    systemProgram?: Address<TAccountSystemProgram>;
+type OpenMarketInstructionDataArgs = {
+    timeToStake: number | bigint;
 };
-declare function getProposeNewFeeClaimerInstructionAsync<TAccountUpdateAuthority extends string, TAccountCentralState extends string, TAccountProposedFeeClaimer extends string, TAccountTimelockedChange extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ProposeNewFeeClaimerAsyncInput<TAccountUpdateAuthority, TAccountCentralState, TAccountProposedFeeClaimer, TAccountTimelockedChange, TAccountSystemProgram>, config?: {
-    programAddress?: TProgramAddress;
-}): Promise<ProposeNewFeeClaimerInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountCentralState, TAccountProposedFeeClaimer, TAccountTimelockedChange, TAccountSystemProgram>>;
-type ProposeNewFeeClaimerInput<TAccountUpdateAuthority extends string = string, TAccountCentralState extends string = string, TAccountProposedFeeClaimer extends string = string, TAccountTimelockedChange extends string = string, TAccountSystemProgram extends string = string> = {
-    updateAuthority: TransactionSigner<TAccountUpdateAuthority>;
-    centralState: Address<TAccountCentralState>;
-    proposedFeeClaimer: Address<TAccountProposedFeeClaimer>;
-    timelockedChange: Address<TAccountTimelockedChange>;
-    systemProgram?: Address<TAccountSystemProgram>;
+declare function getOpenMarketInstructionDataEncoder(): FixedSizeEncoder<OpenMarketInstructionDataArgs>;
+declare function getOpenMarketInstructionDataDecoder(): FixedSizeDecoder<OpenMarketInstructionData>;
+declare function getOpenMarketInstructionDataCodec(): FixedSizeCodec<OpenMarketInstructionDataArgs, OpenMarketInstructionData>;
+type OpenMarketInput<TAccountMarketAuthority extends string = string, TAccountMarket extends string = string, TAccountPlatformConfig extends string = string> = {
+    marketAuthority: TransactionSigner<TAccountMarketAuthority>;
+    market: Address<TAccountMarket>;
+    platformConfig: Address<TAccountPlatformConfig>;
+    timeToStake: OpenMarketInstructionDataArgs['timeToStake'];
 };
-declare function getProposeNewFeeClaimerInstruction<TAccountUpdateAuthority extends string, TAccountCentralState extends string, TAccountProposedFeeClaimer extends string, TAccountTimelockedChange extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ProposeNewFeeClaimerInput<TAccountUpdateAuthority, TAccountCentralState, TAccountProposedFeeClaimer, TAccountTimelockedChange, TAccountSystemProgram>, config?: {
+declare function getOpenMarketInstruction<TAccountMarketAuthority extends string, TAccountMarket extends string, TAccountPlatformConfig extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: OpenMarketInput<TAccountMarketAuthority, TAccountMarket, TAccountPlatformConfig>, config?: {
     programAddress?: TProgramAddress;
-}): ProposeNewFeeClaimerInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountCentralState, TAccountProposedFeeClaimer, TAccountTimelockedChange, TAccountSystemProgram>;
-type ParsedProposeNewFeeClaimerInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+}): OpenMarketInstruction<TProgramAddress, TAccountMarketAuthority, TAccountMarket, TAccountPlatformConfig>;
+type ParsedOpenMarketInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
-        updateAuthority: TAccountMetas[0];
-        centralState: TAccountMetas[1];
-        proposedFeeClaimer: TAccountMetas[2];
-        timelockedChange: TAccountMetas[3];
-        systemProgram: TAccountMetas[4];
+        marketAuthority: TAccountMetas[0];
+        market: TAccountMetas[1];
+        platformConfig: TAccountMetas[2];
     };
-    data: ProposeNewFeeClaimerInstructionData;
+    data: OpenMarketInstructionData;
 };
-declare function parseProposeNewFeeClaimerInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedProposeNewFeeClaimerInstruction<TProgram, TAccountMetas>;
+declare function parseOpenMarketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedOpenMarketInstruction<TProgram, TAccountMetas>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -3058,55 +2810,36 @@ declare function parseProposeNewFeeClaimerInstruction<TProgram extends string, T
  * @see https://github.com/codama-idl/codama
  */
 
-declare const PROPOSE_NEW_UPDATE_AUTHORITY_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getProposeNewUpdateAuthorityDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type ProposeNewUpdateAuthorityInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountUpdateAuthority extends string | AccountMeta<string> = string, TAccountCentralState extends string | AccountMeta<string> = string, TAccountProposedAuthority extends string | AccountMeta<string> = string, TAccountTimelockedChange extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
-    TAccountUpdateAuthority extends string ? WritableSignerAccount<TAccountUpdateAuthority> & AccountSignerMeta<TAccountUpdateAuthority> : TAccountUpdateAuthority,
-    TAccountCentralState extends string ? ReadonlyAccount<TAccountCentralState> : TAccountCentralState,
-    TAccountProposedAuthority extends string ? ReadonlyAccount<TAccountProposedAuthority> : TAccountProposedAuthority,
-    TAccountTimelockedChange extends string ? WritableAccount<TAccountTimelockedChange> : TAccountTimelockedChange,
-    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
+declare const PAUSE_STAKING_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getPauseStakingDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type PauseStakingInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMarketAuthority extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountMarketAuthority extends string ? ReadonlySignerAccount<TAccountMarketAuthority> & AccountSignerMeta<TAccountMarketAuthority> : TAccountMarketAuthority,
+    TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
     ...TRemainingAccounts
 ]>;
-type ProposeNewUpdateAuthorityInstructionData = {
+type PauseStakingInstructionData = {
     discriminator: ReadonlyUint8Array;
 };
-type ProposeNewUpdateAuthorityInstructionDataArgs = {};
-declare function getProposeNewUpdateAuthorityInstructionDataEncoder(): FixedSizeEncoder<ProposeNewUpdateAuthorityInstructionDataArgs>;
-declare function getProposeNewUpdateAuthorityInstructionDataDecoder(): FixedSizeDecoder<ProposeNewUpdateAuthorityInstructionData>;
-declare function getProposeNewUpdateAuthorityInstructionDataCodec(): FixedSizeCodec<ProposeNewUpdateAuthorityInstructionDataArgs, ProposeNewUpdateAuthorityInstructionData>;
-type ProposeNewUpdateAuthorityAsyncInput<TAccountUpdateAuthority extends string = string, TAccountCentralState extends string = string, TAccountProposedAuthority extends string = string, TAccountTimelockedChange extends string = string, TAccountSystemProgram extends string = string> = {
-    updateAuthority: TransactionSigner<TAccountUpdateAuthority>;
-    centralState?: Address<TAccountCentralState>;
-    proposedAuthority: Address<TAccountProposedAuthority>;
-    timelockedChange?: Address<TAccountTimelockedChange>;
-    systemProgram?: Address<TAccountSystemProgram>;
-};
-declare function getProposeNewUpdateAuthorityInstructionAsync<TAccountUpdateAuthority extends string, TAccountCentralState extends string, TAccountProposedAuthority extends string, TAccountTimelockedChange extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ProposeNewUpdateAuthorityAsyncInput<TAccountUpdateAuthority, TAccountCentralState, TAccountProposedAuthority, TAccountTimelockedChange, TAccountSystemProgram>, config?: {
-    programAddress?: TProgramAddress;
-}): Promise<ProposeNewUpdateAuthorityInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountCentralState, TAccountProposedAuthority, TAccountTimelockedChange, TAccountSystemProgram>>;
-type ProposeNewUpdateAuthorityInput<TAccountUpdateAuthority extends string = string, TAccountCentralState extends string = string, TAccountProposedAuthority extends string = string, TAccountTimelockedChange extends string = string, TAccountSystemProgram extends string = string> = {
-    updateAuthority: TransactionSigner<TAccountUpdateAuthority>;
-    centralState: Address<TAccountCentralState>;
-    proposedAuthority: Address<TAccountProposedAuthority>;
-    timelockedChange: Address<TAccountTimelockedChange>;
-    systemProgram?: Address<TAccountSystemProgram>;
+type PauseStakingInstructionDataArgs = {};
+declare function getPauseStakingInstructionDataEncoder(): FixedSizeEncoder<PauseStakingInstructionDataArgs>;
+declare function getPauseStakingInstructionDataDecoder(): FixedSizeDecoder<PauseStakingInstructionData>;
+declare function getPauseStakingInstructionDataCodec(): FixedSizeCodec<PauseStakingInstructionDataArgs, PauseStakingInstructionData>;
+type PauseStakingInput<TAccountMarketAuthority extends string = string, TAccountMarket extends string = string> = {
+    marketAuthority: TransactionSigner<TAccountMarketAuthority>;
+    market: Address<TAccountMarket>;
 };
-declare function getProposeNewUpdateAuthorityInstruction<TAccountUpdateAuthority extends string, TAccountCentralState extends string, TAccountProposedAuthority extends string, TAccountTimelockedChange extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ProposeNewUpdateAuthorityInput<TAccountUpdateAuthority, TAccountCentralState, TAccountProposedAuthority, TAccountTimelockedChange, TAccountSystemProgram>, config?: {
+declare function getPauseStakingInstruction<TAccountMarketAuthority extends string, TAccountMarket extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: PauseStakingInput<TAccountMarketAuthority, TAccountMarket>, config?: {
     programAddress?: TProgramAddress;
-}): ProposeNewUpdateAuthorityInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountCentralState, TAccountProposedAuthority, TAccountTimelockedChange, TAccountSystemProgram>;
-type ParsedProposeNewUpdateAuthorityInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+}): PauseStakingInstruction<TProgramAddress, TAccountMarketAuthority, TAccountMarket>;
+type ParsedPauseStakingInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
-        updateAuthority: TAccountMetas[0];
-        centralState: TAccountMetas[1];
-        proposedAuthority: TAccountMetas[2];
-        timelockedChange: TAccountMetas[3];
-        systemProgram: TAccountMetas[4];
+        marketAuthority: TAccountMetas[0];
+        market: TAccountMetas[1];
     };
-    data: ProposeNewUpdateAuthorityInstructionData;
+    data: PauseStakingInstructionData;
 };
-declare function parseProposeNewUpdateAuthorityInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedProposeNewUpdateAuthorityInstruction<TProgram, TAccountMetas>;
+declare function parsePauseStakingInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedPauseStakingInstruction<TProgram, TAccountMetas>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -3116,82 +2849,36 @@ declare function parseProposeNewUpdateAuthorityInstruction<TProgram extends stri
  * @see https://github.com/codama-idl/codama
  */
 
-declare const RECLAIM_STAKE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getReclaimStakeDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type ReclaimStakeInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TAccountOwner extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountStakeAccount extends string | AccountMeta<string> = string, TAccountTokenMint extends string | AccountMeta<string> = string, TAccountMarketTokenAta extends string | AccountMeta<string> = string, TAccountOwnerTokenAccount extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
-    TAccountSigner extends string ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
-    TAccountOwner extends string ? ReadonlyAccount<TAccountOwner> : TAccountOwner,
-    TAccountMarket extends string ? ReadonlyAccount<TAccountMarket> : TAccountMarket,
-    TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
-    TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
-    TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
-    TAccountOwnerTokenAccount extends string ? WritableAccount<TAccountOwnerTokenAccount> : TAccountOwnerTokenAccount,
-    TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
-    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
+declare const RESOLVE_MARKET_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getResolveMarketDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type ResolveMarketInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMarketAuthority extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountMarketAuthority extends string ? ReadonlySignerAccount<TAccountMarketAuthority> & AccountSignerMeta<TAccountMarketAuthority> : TAccountMarketAuthority,
+    TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
     ...TRemainingAccounts
 ]>;
-type ReclaimStakeInstructionData = {
+type ResolveMarketInstructionData = {
     discriminator: ReadonlyUint8Array;
-    stakeAccountId: number;
-};
-type ReclaimStakeInstructionDataArgs = {
-    stakeAccountId: number;
-};
-declare function getReclaimStakeInstructionDataEncoder(): FixedSizeEncoder<ReclaimStakeInstructionDataArgs>;
-declare function getReclaimStakeInstructionDataDecoder(): FixedSizeDecoder<ReclaimStakeInstructionData>;
-declare function getReclaimStakeInstructionDataCodec(): FixedSizeCodec<ReclaimStakeInstructionDataArgs, ReclaimStakeInstructionData>;
-type ReclaimStakeAsyncInput<TAccountSigner extends string = string, TAccountOwner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountTokenMint extends string = string, TAccountMarketTokenAta extends string = string, TAccountOwnerTokenAccount extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string> = {
-    signer: TransactionSigner<TAccountSigner>;
-    owner: Address<TAccountOwner>;
-    market: Address<TAccountMarket>;
-    stakeAccount?: Address<TAccountStakeAccount>;
-    tokenMint: Address<TAccountTokenMint>;
-    /** Market's ATA holding staked tokens */
-    marketTokenAta?: Address<TAccountMarketTokenAta>;
-    /** Owner's token account to receive staked tokens */
-    ownerTokenAccount: Address<TAccountOwnerTokenAccount>;
-    tokenProgram: Address<TAccountTokenProgram>;
-    systemProgram?: Address<TAccountSystemProgram>;
-    stakeAccountId: ReclaimStakeInstructionDataArgs['stakeAccountId'];
 };
-declare function getReclaimStakeInstructionAsync<TAccountSigner extends string, TAccountOwner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountTokenMint extends string, TAccountMarketTokenAta extends string, TAccountOwnerTokenAccount extends string, TAccountTokenProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ReclaimStakeAsyncInput<TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountOwnerTokenAccount, TAccountTokenProgram, TAccountSystemProgram>, config?: {
-    programAddress?: TProgramAddress;
-}): Promise<ReclaimStakeInstruction<TProgramAddress, TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountOwnerTokenAccount, TAccountTokenProgram, TAccountSystemProgram>>;
-type ReclaimStakeInput<TAccountSigner extends string = string, TAccountOwner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountTokenMint extends string = string, TAccountMarketTokenAta extends string = string, TAccountOwnerTokenAccount extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string> = {
-    signer: TransactionSigner<TAccountSigner>;
-    owner: Address<TAccountOwner>;
+type ResolveMarketInstructionDataArgs = {};
+declare function getResolveMarketInstructionDataEncoder(): FixedSizeEncoder<ResolveMarketInstructionDataArgs>;
+declare function getResolveMarketInstructionDataDecoder(): FixedSizeDecoder<ResolveMarketInstructionData>;
+declare function getResolveMarketInstructionDataCodec(): FixedSizeCodec<ResolveMarketInstructionDataArgs, ResolveMarketInstructionData>;
+type ResolveMarketInput<TAccountMarketAuthority extends string = string, TAccountMarket extends string = string> = {
+    marketAuthority: TransactionSigner<TAccountMarketAuthority>;
     market: Address<TAccountMarket>;
-    stakeAccount: Address<TAccountStakeAccount>;
-    tokenMint: Address<TAccountTokenMint>;
-    /** Market's ATA holding staked tokens */
-    marketTokenAta: Address<TAccountMarketTokenAta>;
-    /** Owner's token account to receive staked tokens */
-    ownerTokenAccount: Address<TAccountOwnerTokenAccount>;
-    tokenProgram: Address<TAccountTokenProgram>;
-    systemProgram?: Address<TAccountSystemProgram>;
-    stakeAccountId: ReclaimStakeInstructionDataArgs['stakeAccountId'];
 };
-declare function getReclaimStakeInstruction<TAccountSigner extends string, TAccountOwner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountTokenMint extends string, TAccountMarketTokenAta extends string, TAccountOwnerTokenAccount extends string, TAccountTokenProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ReclaimStakeInput<TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountOwnerTokenAccount, TAccountTokenProgram, TAccountSystemProgram>, config?: {
+declare function getResolveMarketInstruction<TAccountMarketAuthority extends string, TAccountMarket extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ResolveMarketInput<TAccountMarketAuthority, TAccountMarket>, config?: {
     programAddress?: TProgramAddress;
-}): ReclaimStakeInstruction<TProgramAddress, TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountOwnerTokenAccount, TAccountTokenProgram, TAccountSystemProgram>;
-type ParsedReclaimStakeInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+}): ResolveMarketInstruction<TProgramAddress, TAccountMarketAuthority, TAccountMarket>;
+type ParsedResolveMarketInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
-        signer: TAccountMetas[0];
-        owner: TAccountMetas[1];
-        market: TAccountMetas[2];
-        stakeAccount: TAccountMetas[3];
-        tokenMint: TAccountMetas[4];
-        /** Market's ATA holding staked tokens */
-        marketTokenAta: TAccountMetas[5];
-        /** Owner's token account to receive staked tokens */
-        ownerTokenAccount: TAccountMetas[6];
-        tokenProgram: TAccountMetas[7];
-        systemProgram: TAccountMetas[8];
+        marketAuthority: TAccountMetas[0];
+        market: TAccountMetas[1];
     };
-    data: ReclaimStakeInstructionData;
+    data: ResolveMarketInstructionData;
 };
-declare function parseReclaimStakeInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedReclaimStakeInstruction<TProgram, TAccountMetas>;
+declare function parseResolveMarketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedResolveMarketInstruction<TProgram, TAccountMetas>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -3201,36 +2888,36 @@ declare function parseReclaimStakeInstruction<TProgram extends string, TAccountM
  * @see https://github.com/codama-idl/codama
  */
 
-declare const RESUME_MARKET_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getResumeMarketDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type ResumeMarketInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountAuthority extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
-    TAccountAuthority extends string ? ReadonlySignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority> : TAccountAuthority,
+declare const RESUME_STAKING_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getResumeStakingDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type ResumeStakingInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMarketAuthority extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountMarketAuthority extends string ? ReadonlySignerAccount<TAccountMarketAuthority> & AccountSignerMeta<TAccountMarketAuthority> : TAccountMarketAuthority,
     TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
     ...TRemainingAccounts
 ]>;
-type ResumeMarketInstructionData = {
+type ResumeStakingInstructionData = {
     discriminator: ReadonlyUint8Array;
 };
-type ResumeMarketInstructionDataArgs = {};
-declare function getResumeMarketInstructionDataEncoder(): FixedSizeEncoder<ResumeMarketInstructionDataArgs>;
-declare function getResumeMarketInstructionDataDecoder(): FixedSizeDecoder<ResumeMarketInstructionData>;
-declare function getResumeMarketInstructionDataCodec(): FixedSizeCodec<ResumeMarketInstructionDataArgs, ResumeMarketInstructionData>;
-type ResumeMarketInput<TAccountAuthority extends string = string, TAccountMarket extends string = string> = {
-    authority: TransactionSigner<TAccountAuthority>;
+type ResumeStakingInstructionDataArgs = {};
+declare function getResumeStakingInstructionDataEncoder(): FixedSizeEncoder<ResumeStakingInstructionDataArgs>;
+declare function getResumeStakingInstructionDataDecoder(): FixedSizeDecoder<ResumeStakingInstructionData>;
+declare function getResumeStakingInstructionDataCodec(): FixedSizeCodec<ResumeStakingInstructionDataArgs, ResumeStakingInstructionData>;
+type ResumeStakingInput<TAccountMarketAuthority extends string = string, TAccountMarket extends string = string> = {
+    marketAuthority: TransactionSigner<TAccountMarketAuthority>;
     market: Address<TAccountMarket>;
 };
-declare function getResumeMarketInstruction<TAccountAuthority extends string, TAccountMarket extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ResumeMarketInput<TAccountAuthority, TAccountMarket>, config?: {
+declare function getResumeStakingInstruction<TAccountMarketAuthority extends string, TAccountMarket extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ResumeStakingInput<TAccountMarketAuthority, TAccountMarket>, config?: {
     programAddress?: TProgramAddress;
-}): ResumeMarketInstruction<TProgramAddress, TAccountAuthority, TAccountMarket>;
-type ParsedResumeMarketInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+}): ResumeStakingInstruction<TProgramAddress, TAccountMarketAuthority, TAccountMarket>;
+type ParsedResumeStakingInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
-        authority: TAccountMetas[0];
+        marketAuthority: TAccountMetas[0];
         market: TAccountMetas[1];
     };
-    data: ResumeMarketInstructionData;
+    data: ResumeStakingInstructionData;
 };
-declare function parseResumeMarketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedResumeMarketInstruction<TProgram, TAccountMetas>;
+declare function parseResumeStakingInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedResumeStakingInstruction<TProgram, TAccountMetas>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -3475,40 +3162,140 @@ declare function parseRevealStakeCompDefInstruction<TProgram extends string, TAc
  * @see https://github.com/codama-idl/codama
  */
 
-declare const SELECT_WINNING_OPTIONS_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getSelectWinningOptionsDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type SelectWinningOptionsInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountAuthority extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
-    TAccountAuthority extends string ? ReadonlySignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority> : TAccountAuthority,
+declare const SET_FEE_CLAIM_AUTHORITY_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getSetFeeClaimAuthorityDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type SetFeeClaimAuthorityInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountUpdateAuthority extends string | AccountMeta<string> = string, TAccountPlatformConfig extends string | AccountMeta<string> = string, TAccountNewFeeClaimAuthority extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountUpdateAuthority extends string ? ReadonlySignerAccount<TAccountUpdateAuthority> & AccountSignerMeta<TAccountUpdateAuthority> : TAccountUpdateAuthority,
+    TAccountPlatformConfig extends string ? WritableAccount<TAccountPlatformConfig> : TAccountPlatformConfig,
+    TAccountNewFeeClaimAuthority extends string ? ReadonlyAccount<TAccountNewFeeClaimAuthority> : TAccountNewFeeClaimAuthority,
+    ...TRemainingAccounts
+]>;
+type SetFeeClaimAuthorityInstructionData = {
+    discriminator: ReadonlyUint8Array;
+};
+type SetFeeClaimAuthorityInstructionDataArgs = {};
+declare function getSetFeeClaimAuthorityInstructionDataEncoder(): FixedSizeEncoder<SetFeeClaimAuthorityInstructionDataArgs>;
+declare function getSetFeeClaimAuthorityInstructionDataDecoder(): FixedSizeDecoder<SetFeeClaimAuthorityInstructionData>;
+declare function getSetFeeClaimAuthorityInstructionDataCodec(): FixedSizeCodec<SetFeeClaimAuthorityInstructionDataArgs, SetFeeClaimAuthorityInstructionData>;
+type SetFeeClaimAuthorityInput<TAccountUpdateAuthority extends string = string, TAccountPlatformConfig extends string = string, TAccountNewFeeClaimAuthority extends string = string> = {
+    updateAuthority: TransactionSigner<TAccountUpdateAuthority>;
+    platformConfig: Address<TAccountPlatformConfig>;
+    newFeeClaimAuthority: Address<TAccountNewFeeClaimAuthority>;
+};
+declare function getSetFeeClaimAuthorityInstruction<TAccountUpdateAuthority extends string, TAccountPlatformConfig extends string, TAccountNewFeeClaimAuthority extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: SetFeeClaimAuthorityInput<TAccountUpdateAuthority, TAccountPlatformConfig, TAccountNewFeeClaimAuthority>, config?: {
+    programAddress?: TProgramAddress;
+}): SetFeeClaimAuthorityInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountPlatformConfig, TAccountNewFeeClaimAuthority>;
+type ParsedSetFeeClaimAuthorityInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        updateAuthority: TAccountMetas[0];
+        platformConfig: TAccountMetas[1];
+        newFeeClaimAuthority: TAccountMetas[2];
+    };
+    data: SetFeeClaimAuthorityInstructionData;
+};
+declare function parseSetFeeClaimAuthorityInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedSetFeeClaimAuthorityInstruction<TProgram, TAccountMetas>;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+declare const SET_UPDATE_AUTHORITY_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getSetUpdateAuthorityDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type SetUpdateAuthorityInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountUpdateAuthority extends string | AccountMeta<string> = string, TAccountPlatformConfig extends string | AccountMeta<string> = string, TAccountNewAuthority extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountUpdateAuthority extends string ? ReadonlySignerAccount<TAccountUpdateAuthority> & AccountSignerMeta<TAccountUpdateAuthority> : TAccountUpdateAuthority,
+    TAccountPlatformConfig extends string ? WritableAccount<TAccountPlatformConfig> : TAccountPlatformConfig,
+    TAccountNewAuthority extends string ? ReadonlyAccount<TAccountNewAuthority> : TAccountNewAuthority,
+    ...TRemainingAccounts
+]>;
+type SetUpdateAuthorityInstructionData = {
+    discriminator: ReadonlyUint8Array;
+};
+type SetUpdateAuthorityInstructionDataArgs = {};
+declare function getSetUpdateAuthorityInstructionDataEncoder(): FixedSizeEncoder<SetUpdateAuthorityInstructionDataArgs>;
+declare function getSetUpdateAuthorityInstructionDataDecoder(): FixedSizeDecoder<SetUpdateAuthorityInstructionData>;
+declare function getSetUpdateAuthorityInstructionDataCodec(): FixedSizeCodec<SetUpdateAuthorityInstructionDataArgs, SetUpdateAuthorityInstructionData>;
+type SetUpdateAuthorityInput<TAccountUpdateAuthority extends string = string, TAccountPlatformConfig extends string = string, TAccountNewAuthority extends string = string> = {
+    updateAuthority: TransactionSigner<TAccountUpdateAuthority>;
+    platformConfig: Address<TAccountPlatformConfig>;
+    newAuthority: Address<TAccountNewAuthority>;
+};
+declare function getSetUpdateAuthorityInstruction<TAccountUpdateAuthority extends string, TAccountPlatformConfig extends string, TAccountNewAuthority extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: SetUpdateAuthorityInput<TAccountUpdateAuthority, TAccountPlatformConfig, TAccountNewAuthority>, config?: {
+    programAddress?: TProgramAddress;
+}): SetUpdateAuthorityInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountPlatformConfig, TAccountNewAuthority>;
+type ParsedSetUpdateAuthorityInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        updateAuthority: TAccountMetas[0];
+        platformConfig: TAccountMetas[1];
+        newAuthority: TAccountMetas[2];
+    };
+    data: SetUpdateAuthorityInstructionData;
+};
+declare function parseSetUpdateAuthorityInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedSetUpdateAuthorityInstruction<TProgram, TAccountMetas>;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+declare const SET_WINNING_OPTION_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getSetWinningOptionDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type SetWinningOptionInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMarketAuthority extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountOption extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountMarketAuthority extends string ? ReadonlySignerAccount<TAccountMarketAuthority> & AccountSignerMeta<TAccountMarketAuthority> : TAccountMarketAuthority,
     TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
+    TAccountOption extends string ? WritableAccount<TAccountOption> : TAccountOption,
     ...TRemainingAccounts
 ]>;
-type SelectWinningOptionsInstructionData = {
+type SetWinningOptionInstructionData = {
     discriminator: ReadonlyUint8Array;
-    selections: Array<WinningOption>;
+    optionId: bigint;
+    rewardPercentageBp: number;
+};
+type SetWinningOptionInstructionDataArgs = {
+    optionId: number | bigint;
+    rewardPercentageBp: number;
 };
-type SelectWinningOptionsInstructionDataArgs = {
-    selections: Array<WinningOptionArgs>;
+declare function getSetWinningOptionInstructionDataEncoder(): FixedSizeEncoder<SetWinningOptionInstructionDataArgs>;
+declare function getSetWinningOptionInstructionDataDecoder(): FixedSizeDecoder<SetWinningOptionInstructionData>;
+declare function getSetWinningOptionInstructionDataCodec(): FixedSizeCodec<SetWinningOptionInstructionDataArgs, SetWinningOptionInstructionData>;
+type SetWinningOptionAsyncInput<TAccountMarketAuthority extends string = string, TAccountMarket extends string = string, TAccountOption extends string = string> = {
+    marketAuthority: TransactionSigner<TAccountMarketAuthority>;
+    market: Address<TAccountMarket>;
+    option?: Address<TAccountOption>;
+    optionId: SetWinningOptionInstructionDataArgs['optionId'];
+    rewardPercentageBp: SetWinningOptionInstructionDataArgs['rewardPercentageBp'];
 };
-declare function getSelectWinningOptionsInstructionDataEncoder(): Encoder<SelectWinningOptionsInstructionDataArgs>;
-declare function getSelectWinningOptionsInstructionDataDecoder(): Decoder<SelectWinningOptionsInstructionData>;
-declare function getSelectWinningOptionsInstructionDataCodec(): Codec<SelectWinningOptionsInstructionDataArgs, SelectWinningOptionsInstructionData>;
-type SelectWinningOptionsInput<TAccountAuthority extends string = string, TAccountMarket extends string = string> = {
-    authority: TransactionSigner<TAccountAuthority>;
+declare function getSetWinningOptionInstructionAsync<TAccountMarketAuthority extends string, TAccountMarket extends string, TAccountOption extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: SetWinningOptionAsyncInput<TAccountMarketAuthority, TAccountMarket, TAccountOption>, config?: {
+    programAddress?: TProgramAddress;
+}): Promise<SetWinningOptionInstruction<TProgramAddress, TAccountMarketAuthority, TAccountMarket, TAccountOption>>;
+type SetWinningOptionInput<TAccountMarketAuthority extends string = string, TAccountMarket extends string = string, TAccountOption extends string = string> = {
+    marketAuthority: TransactionSigner<TAccountMarketAuthority>;
     market: Address<TAccountMarket>;
-    selections: SelectWinningOptionsInstructionDataArgs['selections'];
+    option: Address<TAccountOption>;
+    optionId: SetWinningOptionInstructionDataArgs['optionId'];
+    rewardPercentageBp: SetWinningOptionInstructionDataArgs['rewardPercentageBp'];
 };
-declare function getSelectWinningOptionsInstruction<TAccountAuthority extends string, TAccountMarket extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: SelectWinningOptionsInput<TAccountAuthority, TAccountMarket>, config?: {
+declare function getSetWinningOptionInstruction<TAccountMarketAuthority extends string, TAccountMarket extends string, TAccountOption extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: SetWinningOptionInput<TAccountMarketAuthority, TAccountMarket, TAccountOption>, config?: {
     programAddress?: TProgramAddress;
-}): SelectWinningOptionsInstruction<TProgramAddress, TAccountAuthority, TAccountMarket>;
-type ParsedSelectWinningOptionsInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+}): SetWinningOptionInstruction<TProgramAddress, TAccountMarketAuthority, TAccountMarket, TAccountOption>;
+type ParsedSetWinningOptionInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
-        authority: TAccountMetas[0];
+        marketAuthority: TAccountMetas[0];
         market: TAccountMetas[1];
+        option: TAccountMetas[2];
     };
-    data: SelectWinningOptionsInstructionData;
+    data: SetWinningOptionInstructionData;
 };
-declare function parseSelectWinningOptionsInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedSelectWinningOptionsInstruction<TProgram, TAccountMetas>;
+declare function parseSetWinningOptionInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedSetWinningOptionInstruction<TProgram, TAccountMetas>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -3520,17 +3307,14 @@ declare function parseSelectWinningOptionsInstruction<TProgram extends string, T
 
 declare const STAKE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
 declare function getStakeDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type StakeInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TAccountPayer extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountStakeAccount extends string | AccountMeta<string> = string, TAccountTokenMint extends string | AccountMeta<string> = string, TAccountSignerTokenAccount extends string | AccountMeta<string> = string, TAccountMarketTokenAta extends string | AccountMeta<string> = string, TAccountTokenVault extends string | AccountMeta<string> = string, TAccountTokenVaultAta extends string | AccountMeta<string> = string, TAccountCentralState extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = string, TAccountSignPdaAccount extends string | AccountMeta<string> = string, TAccountMxeAccount extends string | AccountMeta<string> = string, TAccountMempoolAccount extends string | AccountMeta<string> = string, TAccountExecutingPool extends string | AccountMeta<string> = string, TAccountComputationAccount extends string | AccountMeta<string> = string, TAccountCompDefAccount extends string | AccountMeta<string> = string, TAccountClusterAccount extends string | AccountMeta<string> = string, TAccountPoolAccount extends string | AccountMeta<string> = 'G2sRWJvi3xoyh5k2gY49eG9L8YhAEWQPtNb1zb1GXTtC', TAccountClockAccount extends string | AccountMeta<string> = '7EbMUTLo5DjdzbN7s8BXeZwXzEwNQb1hScfRvWg8a6ot', TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TAccountArciumProgram extends string | AccountMeta<string> = 'Arcj82pX7HxYKLR92qvgZUAd7vGS1k4hQvAFcPATFdEQ', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+type StakeInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TAccountPayer extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountStakeAccount extends string | AccountMeta<string> = string, TAccountTokenMint extends string | AccountMeta<string> = string, TAccountSignerTokenAccount extends string | AccountMeta<string> = string, TAccountMarketTokenAta extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = string, TAccountSignPdaAccount extends string | AccountMeta<string> = string, TAccountMxeAccount extends string | AccountMeta<string> = string, TAccountMempoolAccount extends string | AccountMeta<string> = string, TAccountExecutingPool extends string | AccountMeta<string> = string, TAccountComputationAccount extends string | AccountMeta<string> = string, TAccountCompDefAccount extends string | AccountMeta<string> = string, TAccountClusterAccount extends string | AccountMeta<string> = string, TAccountPoolAccount extends string | AccountMeta<string> = 'G2sRWJvi3xoyh5k2gY49eG9L8YhAEWQPtNb1zb1GXTtC', TAccountClockAccount extends string | AccountMeta<string> = '7EbMUTLo5DjdzbN7s8BXeZwXzEwNQb1hScfRvWg8a6ot', TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TAccountArciumProgram extends string | AccountMeta<string> = 'Arcj82pX7HxYKLR92qvgZUAd7vGS1k4hQvAFcPATFdEQ', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
     TAccountSigner extends string ? ReadonlySignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
     TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer,
-    TAccountMarket extends string ? ReadonlyAccount<TAccountMarket> : TAccountMarket,
+    TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
     TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
     TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
     TAccountSignerTokenAccount extends string ? WritableAccount<TAccountSignerTokenAccount> : TAccountSignerTokenAccount,
     TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
-    TAccountTokenVault extends string ? WritableAccount<TAccountTokenVault> : TAccountTokenVault,
-    TAccountTokenVaultAta extends string ? WritableAccount<TAccountTokenVaultAta> : TAccountTokenVaultAta,
-    TAccountCentralState extends string ? ReadonlyAccount<TAccountCentralState> : TAccountCentralState,
     TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
     TAccountSignPdaAccount extends string ? WritableAccount<TAccountSignPdaAccount> : TAccountSignPdaAccount,
     TAccountMxeAccount extends string ? ReadonlyAccount<TAccountMxeAccount> : TAccountMxeAccount,
@@ -3554,6 +3338,7 @@ type StakeInstructionData = {
     inputNonce: bigint;
     authorizedReaderNonce: bigint;
     userPubkey: Array<number>;
+    stateNonce: bigint;
 };
 type StakeInstructionDataArgs = {
     computationOffset: number | bigint;
@@ -3563,24 +3348,20 @@ type StakeInstructionDataArgs = {
     inputNonce: number | bigint;
     authorizedReaderNonce: number | bigint;
     userPubkey: Array<number>;
+    stateNonce: number | bigint;
 };
 declare function getStakeInstructionDataEncoder(): FixedSizeEncoder<StakeInstructionDataArgs>;
 declare function getStakeInstructionDataDecoder(): FixedSizeDecoder<StakeInstructionData>;
 declare function getStakeInstructionDataCodec(): FixedSizeCodec<StakeInstructionDataArgs, StakeInstructionData>;
-type StakeAsyncInput<TAccountSigner extends string = string, TAccountPayer extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountTokenMint extends string = string, TAccountSignerTokenAccount extends string = string, TAccountMarketTokenAta extends string = string, TAccountTokenVault extends string = string, TAccountTokenVaultAta extends string = string, TAccountCentralState extends string = string, TAccountTokenProgram extends string = string, TAccountSignPdaAccount extends string = string, TAccountMxeAccount extends string = string, TAccountMempoolAccount extends string = string, TAccountExecutingPool extends string = string, TAccountComputationAccount extends string = string, TAccountCompDefAccount extends string = string, TAccountClusterAccount extends string = string, TAccountPoolAccount extends string = string, TAccountClockAccount extends string = string, TAccountSystemProgram extends string = string, TAccountArciumProgram extends string = string> = {
+type StakeAsyncInput<TAccountSigner extends string = string, TAccountPayer extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountTokenMint extends string = string, TAccountSignerTokenAccount extends string = string, TAccountMarketTokenAta extends string = string, TAccountTokenProgram extends string = string, TAccountSignPdaAccount extends string = string, TAccountMxeAccount extends string = string, TAccountMempoolAccount extends string = string, TAccountExecutingPool extends string = string, TAccountComputationAccount extends string = string, TAccountCompDefAccount extends string = string, TAccountClusterAccount extends string = string, TAccountPoolAccount extends string = string, TAccountClockAccount extends string = string, TAccountSystemProgram extends string = string, TAccountArciumProgram extends string = string> = {
     signer: TransactionSigner<TAccountSigner>;
     payer: TransactionSigner<TAccountPayer>;
     market: Address<TAccountMarket>;
-    stakeAccount?: Address<TAccountStakeAccount>;
+    stakeAccount: Address<TAccountStakeAccount>;
     tokenMint: Address<TAccountTokenMint>;
+    /** Funds the stake. */
     signerTokenAccount: Address<TAccountSignerTokenAccount>;
-    /** Market's ATA for holding staked tokens */
     marketTokenAta?: Address<TAccountMarketTokenAta>;
-    /** Token vault for fee collection */
-    tokenVault?: Address<TAccountTokenVault>;
-    /** Token vault ATA for fee tokens */
-    tokenVaultAta?: Address<TAccountTokenVaultAta>;
-    centralState?: Address<TAccountCentralState>;
     tokenProgram: Address<TAccountTokenProgram>;
     signPdaAccount?: Address<TAccountSignPdaAccount>;
     mxeAccount: Address<TAccountMxeAccount>;
@@ -3600,24 +3381,20 @@ type StakeAsyncInput<TAccountSigner extends string = string, TAccountPayer exten
     inputNonce: StakeInstructionDataArgs['inputNonce'];
     authorizedReaderNonce: StakeInstructionDataArgs['authorizedReaderNonce'];
     userPubkey: StakeInstructionDataArgs['userPubkey'];
+    stateNonce: StakeInstructionDataArgs['stateNonce'];
 };
-declare function getStakeInstructionAsync<TAccountSigner extends string, TAccountPayer extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountTokenMint extends string, TAccountSignerTokenAccount extends string, TAccountMarketTokenAta extends string, TAccountTokenVault extends string, TAccountTokenVaultAta extends string, TAccountCentralState extends string, TAccountTokenProgram extends string, TAccountSignPdaAccount extends string, TAccountMxeAccount extends string, TAccountMempoolAccount extends string, TAccountExecutingPool extends string, TAccountComputationAccount extends string, TAccountCompDefAccount extends string, TAccountClusterAccount extends string, TAccountPoolAccount extends string, TAccountClockAccount extends string, TAccountSystemProgram extends string, TAccountArciumProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: StakeAsyncInput<TAccountSigner, TAccountPayer, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountSignerTokenAccount, TAccountMarketTokenAta, TAccountTokenVault, TAccountTokenVaultAta, TAccountCentralState, TAccountTokenProgram, TAccountSignPdaAccount, TAccountMxeAccount, TAccountMempoolAccount, TAccountExecutingPool, TAccountComputationAccount, TAccountCompDefAccount, TAccountClusterAccount, TAccountPoolAccount, TAccountClockAccount, TAccountSystemProgram, TAccountArciumProgram>, config?: {
+declare function getStakeInstructionAsync<TAccountSigner extends string, TAccountPayer extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountTokenMint extends string, TAccountSignerTokenAccount extends string, TAccountMarketTokenAta extends string, TAccountTokenProgram extends string, TAccountSignPdaAccount extends string, TAccountMxeAccount extends string, TAccountMempoolAccount extends string, TAccountExecutingPool extends string, TAccountComputationAccount extends string, TAccountCompDefAccount extends string, TAccountClusterAccount extends string, TAccountPoolAccount extends string, TAccountClockAccount extends string, TAccountSystemProgram extends string, TAccountArciumProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: StakeAsyncInput<TAccountSigner, TAccountPayer, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountSignerTokenAccount, TAccountMarketTokenAta, TAccountTokenProgram, TAccountSignPdaAccount, TAccountMxeAccount, TAccountMempoolAccount, TAccountExecutingPool, TAccountComputationAccount, TAccountCompDefAccount, TAccountClusterAccount, TAccountPoolAccount, TAccountClockAccount, TAccountSystemProgram, TAccountArciumProgram>, config?: {
     programAddress?: TProgramAddress;
-}): Promise<StakeInstruction<TProgramAddress, TAccountSigner, TAccountPayer, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountSignerTokenAccount, TAccountMarketTokenAta, TAccountTokenVault, TAccountTokenVaultAta, TAccountCentralState, TAccountTokenProgram, TAccountSignPdaAccount, TAccountMxeAccount, TAccountMempoolAccount, TAccountExecutingPool, TAccountComputationAccount, TAccountCompDefAccount, TAccountClusterAccount, TAccountPoolAccount, TAccountClockAccount, TAccountSystemProgram, TAccountArciumProgram>>;
-type StakeInput<TAccountSigner extends string = string, TAccountPayer extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountTokenMint extends string = string, TAccountSignerTokenAccount extends string = string, TAccountMarketTokenAta extends string = string, TAccountTokenVault extends string = string, TAccountTokenVaultAta extends string = string, TAccountCentralState extends string = string, TAccountTokenProgram extends string = string, TAccountSignPdaAccount extends string = string, TAccountMxeAccount extends string = string, TAccountMempoolAccount extends string = string, TAccountExecutingPool extends string = string, TAccountComputationAccount extends string = string, TAccountCompDefAccount extends string = string, TAccountClusterAccount extends string = string, TAccountPoolAccount extends string = string, TAccountClockAccount extends string = string, TAccountSystemProgram extends string = string, TAccountArciumProgram extends string = string> = {
+}): Promise<StakeInstruction<TProgramAddress, TAccountSigner, TAccountPayer, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountSignerTokenAccount, TAccountMarketTokenAta, TAccountTokenProgram, TAccountSignPdaAccount, TAccountMxeAccount, TAccountMempoolAccount, TAccountExecutingPool, TAccountComputationAccount, TAccountCompDefAccount, TAccountClusterAccount, TAccountPoolAccount, TAccountClockAccount, TAccountSystemProgram, TAccountArciumProgram>>;
+type StakeInput<TAccountSigner extends string = string, TAccountPayer extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountTokenMint extends string = string, TAccountSignerTokenAccount extends string = string, TAccountMarketTokenAta extends string = string, TAccountTokenProgram extends string = string, TAccountSignPdaAccount extends string = string, TAccountMxeAccount extends string = string, TAccountMempoolAccount extends string = string, TAccountExecutingPool extends string = string, TAccountComputationAccount extends string = string, TAccountCompDefAccount extends string = string, TAccountClusterAccount extends string = string, TAccountPoolAccount extends string = string, TAccountClockAccount extends string = string, TAccountSystemProgram extends string = string, TAccountArciumProgram extends string = string> = {
     signer: TransactionSigner<TAccountSigner>;
     payer: TransactionSigner<TAccountPayer>;
     market: Address<TAccountMarket>;
     stakeAccount: Address<TAccountStakeAccount>;
     tokenMint: Address<TAccountTokenMint>;
+    /** Funds the stake. */
     signerTokenAccount: Address<TAccountSignerTokenAccount>;
-    /** Market's ATA for holding staked tokens */
     marketTokenAta: Address<TAccountMarketTokenAta>;
-    /** Token vault for fee collection */
-    tokenVault: Address<TAccountTokenVault>;
-    /** Token vault ATA for fee tokens */
-    tokenVaultAta: Address<TAccountTokenVaultAta>;
-    centralState: Address<TAccountCentralState>;
     tokenProgram: Address<TAccountTokenProgram>;
     signPdaAccount: Address<TAccountSignPdaAccount>;
     mxeAccount: Address<TAccountMxeAccount>;
@@ -3637,10 +3414,11 @@ type StakeInput<TAccountSigner extends string = string, TAccountPayer extends st
     inputNonce: StakeInstructionDataArgs['inputNonce'];
     authorizedReaderNonce: StakeInstructionDataArgs['authorizedReaderNonce'];
     userPubkey: StakeInstructionDataArgs['userPubkey'];
+    stateNonce: StakeInstructionDataArgs['stateNonce'];
 };
-declare function getStakeInstruction<TAccountSigner extends string, TAccountPayer extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountTokenMint extends string, TAccountSignerTokenAccount extends string, TAccountMarketTokenAta extends string, TAccountTokenVault extends string, TAccountTokenVaultAta extends string, TAccountCentralState extends string, TAccountTokenProgram extends string, TAccountSignPdaAccount extends string, TAccountMxeAccount extends string, TAccountMempoolAccount extends string, TAccountExecutingPool extends string, TAccountComputationAccount extends string, TAccountCompDefAccount extends string, TAccountClusterAccount extends string, TAccountPoolAccount extends string, TAccountClockAccount extends string, TAccountSystemProgram extends string, TAccountArciumProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: StakeInput<TAccountSigner, TAccountPayer, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountSignerTokenAccount, TAccountMarketTokenAta, TAccountTokenVault, TAccountTokenVaultAta, TAccountCentralState, TAccountTokenProgram, TAccountSignPdaAccount, TAccountMxeAccount, TAccountMempoolAccount, TAccountExecutingPool, TAccountComputationAccount, TAccountCompDefAccount, TAccountClusterAccount, TAccountPoolAccount, TAccountClockAccount, TAccountSystemProgram, TAccountArciumProgram>, config?: {
+declare function getStakeInstruction<TAccountSigner extends string, TAccountPayer extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountTokenMint extends string, TAccountSignerTokenAccount extends string, TAccountMarketTokenAta extends string, TAccountTokenProgram extends string, TAccountSignPdaAccount extends string, TAccountMxeAccount extends string, TAccountMempoolAccount extends string, TAccountExecutingPool extends string, TAccountComputationAccount extends string, TAccountCompDefAccount extends string, TAccountClusterAccount extends string, TAccountPoolAccount extends string, TAccountClockAccount extends string, TAccountSystemProgram extends string, TAccountArciumProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: StakeInput<TAccountSigner, TAccountPayer, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountSignerTokenAccount, TAccountMarketTokenAta, TAccountTokenProgram, TAccountSignPdaAccount, TAccountMxeAccount, TAccountMempoolAccount, TAccountExecutingPool, TAccountComputationAccount, TAccountCompDefAccount, TAccountClusterAccount, TAccountPoolAccount, TAccountClockAccount, TAccountSystemProgram, TAccountArciumProgram>, config?: {
     programAddress?: TProgramAddress;
-}): StakeInstruction<TProgramAddress, TAccountSigner, TAccountPayer, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountSignerTokenAccount, TAccountMarketTokenAta, TAccountTokenVault, TAccountTokenVaultAta, TAccountCentralState, TAccountTokenProgram, TAccountSignPdaAccount, TAccountMxeAccount, TAccountMempoolAccount, TAccountExecutingPool, TAccountComputationAccount, TAccountCompDefAccount, TAccountClusterAccount, TAccountPoolAccount, TAccountClockAccount, TAccountSystemProgram, TAccountArciumProgram>;
+}): StakeInstruction<TProgramAddress, TAccountSigner, TAccountPayer, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountSignerTokenAccount, TAccountMarketTokenAta, TAccountTokenProgram, TAccountSignPdaAccount, TAccountMxeAccount, TAccountMempoolAccount, TAccountExecutingPool, TAccountComputationAccount, TAccountCompDefAccount, TAccountClusterAccount, TAccountPoolAccount, TAccountClockAccount, TAccountSystemProgram, TAccountArciumProgram>;
 type ParsedStakeInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
@@ -3649,26 +3427,21 @@ type ParsedStakeInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_
         market: TAccountMetas[2];
         stakeAccount: TAccountMetas[3];
         tokenMint: TAccountMetas[4];
+        /** Funds the stake. */
         signerTokenAccount: TAccountMetas[5];
-        /** Market's ATA for holding staked tokens */
         marketTokenAta: TAccountMetas[6];
-        /** Token vault for fee collection */
-        tokenVault: TAccountMetas[7];
-        /** Token vault ATA for fee tokens */
-        tokenVaultAta: TAccountMetas[8];
-        centralState: TAccountMetas[9];
-        tokenProgram: TAccountMetas[10];
-        signPdaAccount: TAccountMetas[11];
-        mxeAccount: TAccountMetas[12];
-        mempoolAccount: TAccountMetas[13];
-        executingPool: TAccountMetas[14];
-        computationAccount: TAccountMetas[15];
-        compDefAccount: TAccountMetas[16];
-        clusterAccount: TAccountMetas[17];
-        poolAccount: TAccountMetas[18];
-        clockAccount: TAccountMetas[19];
-        systemProgram: TAccountMetas[20];
-        arciumProgram: TAccountMetas[21];
+        tokenProgram: TAccountMetas[7];
+        signPdaAccount: TAccountMetas[8];
+        mxeAccount: TAccountMetas[9];
+        mempoolAccount: TAccountMetas[10];
+        executingPool: TAccountMetas[11];
+        computationAccount: TAccountMetas[12];
+        compDefAccount: TAccountMetas[13];
+        clusterAccount: TAccountMetas[14];
+        poolAccount: TAccountMetas[15];
+        clockAccount: TAccountMetas[16];
+        systemProgram: TAccountMetas[17];
+        arciumProgram: TAccountMetas[18];
     };
     data: StakeInstructionData;
 };
@@ -3684,16 +3457,15 @@ declare function parseStakeInstruction<TProgram extends string, TAccountMetas ex
 
 declare const STAKE_CALLBACK_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
 declare function getStakeCallbackDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type StakeCallbackInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountArciumProgram extends string | AccountMeta<string> = 'Arcj82pX7HxYKLR92qvgZUAd7vGS1k4hQvAFcPATFdEQ', TAccountCompDefAccount extends string | AccountMeta<string> = string, TAccountMxeAccount extends string | AccountMeta<string> = string, TAccountComputationAccount extends string | AccountMeta<string> = string, TAccountClusterAccount extends string | AccountMeta<string> = string, TAccountInstructionsSysvar extends string | AccountMeta<string> = 'Sysvar1nstructions1111111111111111111111111', TAccountMarket extends string | AccountMeta<string> = string, TAccountStakeAccount extends string | AccountMeta<string> = string, TAccountTokenVault extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+type StakeCallbackInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountArciumProgram extends string | AccountMeta<string> = 'Arcj82pX7HxYKLR92qvgZUAd7vGS1k4hQvAFcPATFdEQ', TAccountCompDefAccount extends string | AccountMeta<string> = string, TAccountMxeAccount extends string | AccountMeta<string> = string, TAccountComputationAccount extends string | AccountMeta<string> = string, TAccountClusterAccount extends string | AccountMeta<string> = string, TAccountInstructionsSysvar extends string | AccountMeta<string> = 'Sysvar1nstructions1111111111111111111111111', TAccountStakeAccount extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
     TAccountArciumProgram extends string ? ReadonlyAccount<TAccountArciumProgram> : TAccountArciumProgram,
     TAccountCompDefAccount extends string ? ReadonlyAccount<TAccountCompDefAccount> : TAccountCompDefAccount,
     TAccountMxeAccount extends string ? ReadonlyAccount<TAccountMxeAccount> : TAccountMxeAccount,
     TAccountComputationAccount extends string ? ReadonlyAccount<TAccountComputationAccount> : TAccountComputationAccount,
     TAccountClusterAccount extends string ? ReadonlyAccount<TAccountClusterAccount> : TAccountClusterAccount,
     TAccountInstructionsSysvar extends string ? ReadonlyAccount<TAccountInstructionsSysvar> : TAccountInstructionsSysvar,
-    TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
     TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
-    TAccountTokenVault extends string ? WritableAccount<TAccountTokenVault> : TAccountTokenVault,
+    TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
     ...TRemainingAccounts
 ]>;
 type StakeCallbackInstructionData = {
@@ -3722,21 +3494,20 @@ type StakeCallbackInstructionDataArgs = {
 declare function getStakeCallbackInstructionDataEncoder(): Encoder<StakeCallbackInstructionDataArgs>;
 declare function getStakeCallbackInstructionDataDecoder(): Decoder<StakeCallbackInstructionData>;
 declare function getStakeCallbackInstructionDataCodec(): Codec<StakeCallbackInstructionDataArgs, StakeCallbackInstructionData>;
-type StakeCallbackInput<TAccountArciumProgram extends string = string, TAccountCompDefAccount extends string = string, TAccountMxeAccount extends string = string, TAccountComputationAccount extends string = string, TAccountClusterAccount extends string = string, TAccountInstructionsSysvar extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountTokenVault extends string = string> = {
+type StakeCallbackInput<TAccountArciumProgram extends string = string, TAccountCompDefAccount extends string = string, TAccountMxeAccount extends string = string, TAccountComputationAccount extends string = string, TAccountClusterAccount extends string = string, TAccountInstructionsSysvar extends string = string, TAccountStakeAccount extends string = string, TAccountMarket extends string = string> = {
     arciumProgram?: Address<TAccountArciumProgram>;
     compDefAccount: Address<TAccountCompDefAccount>;
     mxeAccount: Address<TAccountMxeAccount>;
     computationAccount: Address<TAccountComputationAccount>;
     clusterAccount: Address<TAccountClusterAccount>;
     instructionsSysvar?: Address<TAccountInstructionsSysvar>;
-    market: Address<TAccountMarket>;
     stakeAccount: Address<TAccountStakeAccount>;
-    tokenVault: Address<TAccountTokenVault>;
+    market: Address<TAccountMarket>;
     output: StakeCallbackInstructionDataArgs['output'];
 };
-declare function getStakeCallbackInstruction<TAccountArciumProgram extends string, TAccountCompDefAccount extends string, TAccountMxeAccount extends string, TAccountComputationAccount extends string, TAccountClusterAccount extends string, TAccountInstructionsSysvar extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountTokenVault extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: StakeCallbackInput<TAccountArciumProgram, TAccountCompDefAccount, TAccountMxeAccount, TAccountComputationAccount, TAccountClusterAccount, TAccountInstructionsSysvar, TAccountMarket, TAccountStakeAccount, TAccountTokenVault>, config?: {
+declare function getStakeCallbackInstruction<TAccountArciumProgram extends string, TAccountCompDefAccount extends string, TAccountMxeAccount extends string, TAccountComputationAccount extends string, TAccountClusterAccount extends string, TAccountInstructionsSysvar extends string, TAccountStakeAccount extends string, TAccountMarket extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: StakeCallbackInput<TAccountArciumProgram, TAccountCompDefAccount, TAccountMxeAccount, TAccountComputationAccount, TAccountClusterAccount, TAccountInstructionsSysvar, TAccountStakeAccount, TAccountMarket>, config?: {
     programAddress?: TProgramAddress;
-}): StakeCallbackInstruction<TProgramAddress, TAccountArciumProgram, TAccountCompDefAccount, TAccountMxeAccount, TAccountComputationAccount, TAccountClusterAccount, TAccountInstructionsSysvar, TAccountMarket, TAccountStakeAccount, TAccountTokenVault>;
+}): StakeCallbackInstruction<TProgramAddress, TAccountArciumProgram, TAccountCompDefAccount, TAccountMxeAccount, TAccountComputationAccount, TAccountClusterAccount, TAccountInstructionsSysvar, TAccountStakeAccount, TAccountMarket>;
 type ParsedStakeCallbackInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
@@ -3746,9 +3517,8 @@ type ParsedStakeCallbackInstruction<TProgram extends string = typeof OPPORTUNITY
         computationAccount: TAccountMetas[3];
         clusterAccount: TAccountMetas[4];
         instructionsSysvar: TAccountMetas[5];
-        market: TAccountMetas[6];
-        stakeAccount: TAccountMetas[7];
-        tokenVault: TAccountMetas[8];
+        stakeAccount: TAccountMetas[6];
+        market: TAccountMetas[7];
     };
     data: StakeCallbackInstructionData;
 };
@@ -3816,52 +3586,79 @@ declare function parseStakeCompDefInstruction<TProgram extends string, TAccountM
  * @see https://github.com/codama-idl/codama
  */
 
-declare const UNSTAKE_EARLY_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getUnstakeEarlyDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type UnstakeEarlyInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountStakeAccount extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+declare const UNSTAKE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getUnstakeDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type UnstakeInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountSigner extends string | AccountMeta<string> = string, TAccountOwner extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountStakeAccount extends string | AccountMeta<string> = string, TAccountTokenMint extends string | AccountMeta<string> = string, TAccountMarketTokenAta extends string | AccountMeta<string> = string, TAccountOwnerTokenAccount extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
     TAccountSigner extends string ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
+    TAccountOwner extends string ? ReadonlyAccount<TAccountOwner> : TAccountOwner,
     TAccountMarket extends string ? ReadonlyAccount<TAccountMarket> : TAccountMarket,
     TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
+    TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
+    TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
+    TAccountOwnerTokenAccount extends string ? WritableAccount<TAccountOwnerTokenAccount> : TAccountOwnerTokenAccount,
+    TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
+    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
     ...TRemainingAccounts
 ]>;
-type UnstakeEarlyInstructionData = {
+type UnstakeInstructionData = {
     discriminator: ReadonlyUint8Array;
     stakeAccountId: number;
 };
-type UnstakeEarlyInstructionDataArgs = {
+type UnstakeInstructionDataArgs = {
     stakeAccountId: number;
 };
-declare function getUnstakeEarlyInstructionDataEncoder(): FixedSizeEncoder<UnstakeEarlyInstructionDataArgs>;
-declare function getUnstakeEarlyInstructionDataDecoder(): FixedSizeDecoder<UnstakeEarlyInstructionData>;
-declare function getUnstakeEarlyInstructionDataCodec(): FixedSizeCodec<UnstakeEarlyInstructionDataArgs, UnstakeEarlyInstructionData>;
-type UnstakeEarlyAsyncInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string> = {
+declare function getUnstakeInstructionDataEncoder(): FixedSizeEncoder<UnstakeInstructionDataArgs>;
+declare function getUnstakeInstructionDataDecoder(): FixedSizeDecoder<UnstakeInstructionData>;
+declare function getUnstakeInstructionDataCodec(): FixedSizeCodec<UnstakeInstructionDataArgs, UnstakeInstructionData>;
+type UnstakeAsyncInput<TAccountSigner extends string = string, TAccountOwner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountTokenMint extends string = string, TAccountMarketTokenAta extends string = string, TAccountOwnerTokenAccount extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string> = {
     signer: TransactionSigner<TAccountSigner>;
+    owner: Address<TAccountOwner>;
     market: Address<TAccountMarket>;
     stakeAccount?: Address<TAccountStakeAccount>;
-    stakeAccountId: UnstakeEarlyInstructionDataArgs['stakeAccountId'];
+    tokenMint: Address<TAccountTokenMint>;
+    marketTokenAta?: Address<TAccountMarketTokenAta>;
+    /** Owner's token account to receive staked tokens */
+    ownerTokenAccount: Address<TAccountOwnerTokenAccount>;
+    tokenProgram: Address<TAccountTokenProgram>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    stakeAccountId: UnstakeInstructionDataArgs['stakeAccountId'];
 };
-declare function getUnstakeEarlyInstructionAsync<TAccountSigner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: UnstakeEarlyAsyncInput<TAccountSigner, TAccountMarket, TAccountStakeAccount>, config?: {
+declare function getUnstakeInstructionAsync<TAccountSigner extends string, TAccountOwner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountTokenMint extends string, TAccountMarketTokenAta extends string, TAccountOwnerTokenAccount extends string, TAccountTokenProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: UnstakeAsyncInput<TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountOwnerTokenAccount, TAccountTokenProgram, TAccountSystemProgram>, config?: {
     programAddress?: TProgramAddress;
-}): Promise<UnstakeEarlyInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount>>;
-type UnstakeEarlyInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string> = {
+}): Promise<UnstakeInstruction<TProgramAddress, TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountOwnerTokenAccount, TAccountTokenProgram, TAccountSystemProgram>>;
+type UnstakeInput<TAccountSigner extends string = string, TAccountOwner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountTokenMint extends string = string, TAccountMarketTokenAta extends string = string, TAccountOwnerTokenAccount extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string> = {
     signer: TransactionSigner<TAccountSigner>;
+    owner: Address<TAccountOwner>;
     market: Address<TAccountMarket>;
     stakeAccount: Address<TAccountStakeAccount>;
-    stakeAccountId: UnstakeEarlyInstructionDataArgs['stakeAccountId'];
+    tokenMint: Address<TAccountTokenMint>;
+    marketTokenAta: Address<TAccountMarketTokenAta>;
+    /** Owner's token account to receive staked tokens */
+    ownerTokenAccount: Address<TAccountOwnerTokenAccount>;
+    tokenProgram: Address<TAccountTokenProgram>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    stakeAccountId: UnstakeInstructionDataArgs['stakeAccountId'];
 };
-declare function getUnstakeEarlyInstruction<TAccountSigner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: UnstakeEarlyInput<TAccountSigner, TAccountMarket, TAccountStakeAccount>, config?: {
+declare function getUnstakeInstruction<TAccountSigner extends string, TAccountOwner extends string, TAccountMarket extends string, TAccountStakeAccount extends string, TAccountTokenMint extends string, TAccountMarketTokenAta extends string, TAccountOwnerTokenAccount extends string, TAccountTokenProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: UnstakeInput<TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountOwnerTokenAccount, TAccountTokenProgram, TAccountSystemProgram>, config?: {
     programAddress?: TProgramAddress;
-}): UnstakeEarlyInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount>;
-type ParsedUnstakeEarlyInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+}): UnstakeInstruction<TProgramAddress, TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountOwnerTokenAccount, TAccountTokenProgram, TAccountSystemProgram>;
+type ParsedUnstakeInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
         signer: TAccountMetas[0];
-        market: TAccountMetas[1];
-        stakeAccount: TAccountMetas[2];
+        owner: TAccountMetas[1];
+        market: TAccountMetas[2];
+        stakeAccount: TAccountMetas[3];
+        tokenMint: TAccountMetas[4];
+        marketTokenAta: TAccountMetas[5];
+        /** Owner's token account to receive staked tokens */
+        ownerTokenAccount: TAccountMetas[6];
+        tokenProgram: TAccountMetas[7];
+        systemProgram: TAccountMetas[8];
     };
-    data: UnstakeEarlyInstructionData;
+    data: UnstakeInstructionData;
 };
-declare function parseUnstakeEarlyInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedUnstakeEarlyInstruction<TProgram, TAccountMetas>;
+declare function parseUnstakeInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedUnstakeInstruction<TProgram, TAccountMetas>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -3871,48 +3668,58 @@ declare function parseUnstakeEarlyInstruction<TProgram extends string, TAccountM
  * @see https://github.com/codama-idl/codama
  */
 
-declare const UPDATE_CENTRAL_STATE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
-declare function getUpdateCentralStateDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
-type UpdateCentralStateInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountUpdateAuthority extends string | AccountMeta<string> = string, TAccountCentralState extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+declare const UPDATE_PLATFORM_CONFIG_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getUpdatePlatformConfigDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type UpdatePlatformConfigInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountUpdateAuthority extends string | AccountMeta<string> = string, TAccountPlatformConfig extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
     TAccountUpdateAuthority extends string ? ReadonlySignerAccount<TAccountUpdateAuthority> & AccountSignerMeta<TAccountUpdateAuthority> : TAccountUpdateAuthority,
-    TAccountCentralState extends string ? WritableAccount<TAccountCentralState> : TAccountCentralState,
+    TAccountPlatformConfig extends string ? WritableAccount<TAccountPlatformConfig> : TAccountPlatformConfig,
     ...TRemainingAccounts
 ]>;
-type UpdateCentralStateInstructionData = {
+type UpdatePlatformConfigInstructionData = {
     discriminator: ReadonlyUint8Array;
-    protocolFeeBp: number;
-};
-type UpdateCentralStateInstructionDataArgs = {
-    protocolFeeBp: number;
-};
-declare function getUpdateCentralStateInstructionDataEncoder(): FixedSizeEncoder<UpdateCentralStateInstructionDataArgs>;
-declare function getUpdateCentralStateInstructionDataDecoder(): FixedSizeDecoder<UpdateCentralStateInstructionData>;
-declare function getUpdateCentralStateInstructionDataCodec(): FixedSizeCodec<UpdateCentralStateInstructionDataArgs, UpdateCentralStateInstructionData>;
-type UpdateCentralStateAsyncInput<TAccountUpdateAuthority extends string = string, TAccountCentralState extends string = string> = {
-    updateAuthority: TransactionSigner<TAccountUpdateAuthority>;
-    centralState?: Address<TAccountCentralState>;
-    protocolFeeBp: UpdateCentralStateInstructionDataArgs['protocolFeeBp'];
-};
-declare function getUpdateCentralStateInstructionAsync<TAccountUpdateAuthority extends string, TAccountCentralState extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: UpdateCentralStateAsyncInput<TAccountUpdateAuthority, TAccountCentralState>, config?: {
-    programAddress?: TProgramAddress;
-}): Promise<UpdateCentralStateInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountCentralState>>;
-type UpdateCentralStateInput<TAccountUpdateAuthority extends string = string, TAccountCentralState extends string = string> = {
+    platformFeeBp: number;
+    rewardPoolFeeBp: number;
+    creatorFeeBp: number;
+    minTimeToStakeSeconds: bigint;
+    minRevealPeriodSeconds: bigint;
+    maxRevealPeriodSeconds: bigint;
+    marketResolutionDeadlineSeconds: bigint;
+};
+type UpdatePlatformConfigInstructionDataArgs = {
+    platformFeeBp: number;
+    rewardPoolFeeBp: number;
+    creatorFeeBp: number;
+    minTimeToStakeSeconds: number | bigint;
+    minRevealPeriodSeconds: number | bigint;
+    maxRevealPeriodSeconds: number | bigint;
+    marketResolutionDeadlineSeconds: number | bigint;
+};
+declare function getUpdatePlatformConfigInstructionDataEncoder(): FixedSizeEncoder<UpdatePlatformConfigInstructionDataArgs>;
+declare function getUpdatePlatformConfigInstructionDataDecoder(): FixedSizeDecoder<UpdatePlatformConfigInstructionData>;
+declare function getUpdatePlatformConfigInstructionDataCodec(): FixedSizeCodec<UpdatePlatformConfigInstructionDataArgs, UpdatePlatformConfigInstructionData>;
+type UpdatePlatformConfigInput<TAccountUpdateAuthority extends string = string, TAccountPlatformConfig extends string = string> = {
     updateAuthority: TransactionSigner<TAccountUpdateAuthority>;
-    centralState: Address<TAccountCentralState>;
-    protocolFeeBp: UpdateCentralStateInstructionDataArgs['protocolFeeBp'];
-};
-declare function getUpdateCentralStateInstruction<TAccountUpdateAuthority extends string, TAccountCentralState extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: UpdateCentralStateInput<TAccountUpdateAuthority, TAccountCentralState>, config?: {
+    platformConfig: Address<TAccountPlatformConfig>;
+    platformFeeBp: UpdatePlatformConfigInstructionDataArgs['platformFeeBp'];
+    rewardPoolFeeBp: UpdatePlatformConfigInstructionDataArgs['rewardPoolFeeBp'];
+    creatorFeeBp: UpdatePlatformConfigInstructionDataArgs['creatorFeeBp'];
+    minTimeToStakeSeconds: UpdatePlatformConfigInstructionDataArgs['minTimeToStakeSeconds'];
+    minRevealPeriodSeconds: UpdatePlatformConfigInstructionDataArgs['minRevealPeriodSeconds'];
+    maxRevealPeriodSeconds: UpdatePlatformConfigInstructionDataArgs['maxRevealPeriodSeconds'];
+    marketResolutionDeadlineSeconds: UpdatePlatformConfigInstructionDataArgs['marketResolutionDeadlineSeconds'];
+};
+declare function getUpdatePlatformConfigInstruction<TAccountUpdateAuthority extends string, TAccountPlatformConfig extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: UpdatePlatformConfigInput<TAccountUpdateAuthority, TAccountPlatformConfig>, config?: {
     programAddress?: TProgramAddress;
-}): UpdateCentralStateInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountCentralState>;
-type ParsedUpdateCentralStateInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+}): UpdatePlatformConfigInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountPlatformConfig>;
+type ParsedUpdatePlatformConfigInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
     programAddress: Address<TProgram>;
     accounts: {
         updateAuthority: TAccountMetas[0];
-        centralState: TAccountMetas[1];
+        platformConfig: TAccountMetas[1];
     };
-    data: UpdateCentralStateInstructionData;
+    data: UpdatePlatformConfigInstructionData;
 };
-declare function parseUpdateCentralStateInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedUpdateCentralStateInstruction<TProgram, TAccountMetas>;
+declare function parseUpdatePlatformConfigInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedUpdatePlatformConfigInstruction<TProgram, TAccountMetas>;
 
 /**
  * This code was AUTOGENERATED using the Codama library.
@@ -3946,7 +3753,6 @@ type WithdrawRewardAsyncInput<TAccountSponsor extends string = string, TAccountM
     market: Address<TAccountMarket>;
     sponsorAccount?: Address<TAccountSponsorAccount>;
     tokenMint: Address<TAccountTokenMint>;
-    /** Market's ATA holding reward tokens */
     marketTokenAta?: Address<TAccountMarketTokenAta>;
     /** Sponsor's destination for refunded reward tokens */
     refundTokenAccount: Address<TAccountRefundTokenAccount>;
@@ -3960,7 +3766,6 @@ type WithdrawRewardInput<TAccountSponsor extends string = string, TAccountMarket
     market: Address<TAccountMarket>;
     sponsorAccount: Address<TAccountSponsorAccount>;
     tokenMint: Address<TAccountTokenMint>;
-    /** Market's ATA holding reward tokens */
     marketTokenAta: Address<TAccountMarketTokenAta>;
     /** Sponsor's destination for refunded reward tokens */
     refundTokenAccount: Address<TAccountRefundTokenAccount>;
@@ -3976,7 +3781,6 @@ type ParsedWithdrawRewardInstruction<TProgram extends string = typeof OPPORTUNIT
         market: TAccountMetas[1];
         sponsorAccount: TAccountMetas[2];
         tokenMint: TAccountMetas[3];
-        /** Market's ATA holding reward tokens */
         marketTokenAta: TAccountMetas[4];
         /** Sponsor's destination for refunded reward tokens */
         refundTokenAccount: TAccountMetas[5];
@@ -3990,12 +3794,6 @@ interface BaseInstructionParams {
     programAddress?: Address;
 }
 
-interface InitTokenVaultParams extends BaseInstructionParams {
-    payer: TransactionSigner;
-    tokenMint: Address;
-}
-declare function initTokenVault(input: InitTokenVaultParams): Promise<InitTokenVaultInstruction<string>>;
-
 /**
  * Generates a random computation offset for Arcium computations.
  * Returns a BigInt from 8 random bytes.
@@ -4019,17 +3817,18 @@ declare function toNumberArray(bytes: ByteArray): number[];
 
 interface CreateMarketParams extends BaseInstructionParams {
     creator: TransactionSigner;
+    platformConfig: Address;
     tokenMint: Address;
     tokenProgram: Address;
     marketIndex: bigint;
-    timeToStake: bigint;
-    timeToReveal: bigint;
-    marketAuthority: Address | null;
-    unstakeDelaySeconds: bigint;
+    marketAuthority: Address;
+    allowUnstakingEarly: boolean;
     authorizedReaderPubkey: ByteArray;
-    allowClosingEarly: boolean;
     revealPeriodAuthority: Address;
     earlinessCutoffSeconds: bigint;
+    earlinessMultiplier: number;
+    minStakeAmount: bigint;
+    creatorFeeClaimer: Address;
 }
 declare function createMarket(input: CreateMarketParams): Promise<CreateMarketInstruction<string>>;
 
@@ -4037,7 +3836,10 @@ type CompDefCircuitName = "stake" | "reveal_stake";
 declare const ALL_COMP_DEF_CIRCUITS: CompDefCircuitName[];
 interface InitCompDefConfig extends BaseInstructionParams {
 }
-declare function getMxeAccount(rpc: Rpc<SolanaRpcApi>, programId?: Address): Promise<_solana_accounts.Account<MXEAccount, string>>;
+declare function getMxeAccount(rpc: Rpc<SolanaRpcApi>, programId?: Address): Promise<{
+    address: Address;
+    data: MXEAccount;
+}>;
 declare function getCompDefAccount(circuitName: CompDefCircuitName, programId?: Address): Address;
 declare function getCompDefOffsetNumber(circuitName: CompDefCircuitName): number;
 declare function getInitCompDefInstruction(rpc: Rpc<SolanaRpcApi>, payer: TransactionSigner, circuitName: CompDefCircuitName, config?: InitCompDefConfig): Promise<Instruction>;
@@ -4052,18 +3854,21 @@ interface StakeParams extends BaseInstructionParams {
     signer: TransactionSigner;
     payer: TransactionSigner;
     market: Address;
+    /** PDA of the stake_account being staked into. Use `getStakeAccountAddress(owner, market, id)`. */
+    stakeAccount: Address;
     stakeAccountId: number;
     tokenMint: Address;
     signerTokenAccount: Address;
-    marketTokenAta: Address;
-    tokenVault: Address;
-    tokenVaultAta: Address;
     tokenProgram: Address;
+    /** Gross amount (net + fee). Fee is deducted on-chain and routed to the fee vault ATA. */
     amount: bigint;
     selectedOptionCiphertext: ByteArray;
     inputNonce: bigint;
     authorizedReaderNonce: bigint;
+    /** User's x25519 public key (NOT their Solana wallet pubkey). */
     userPubkey: ByteArray;
+    /** u128 nonce committed to encrypted-state derivation. */
+    stateNonce: bigint;
 }
 declare function stake(input: StakeParams, config: ArciumConfig): Promise<StakeInstruction<string>>;
 
@@ -4076,40 +3881,48 @@ interface RevealStakeParams extends BaseInstructionParams {
 declare function revealStake(input: RevealStakeParams, config: ArciumConfig): Promise<RevealStakeInstruction<string>>;
 
 interface AddMarketOptionParams extends BaseInstructionParams {
-    creator: TransactionSigner;
+    signer: TransactionSigner;
     market: Address;
     optionId: number | bigint;
 }
 declare function addMarketOption(input: AddMarketOptionParams): Promise<AddMarketOptionInstruction<string>>;
 
 interface OpenMarketParams extends BaseInstructionParams {
-    creator: TransactionSigner;
+    marketAuthority: TransactionSigner;
     market: Address;
-    openTimestamp: bigint;
+    platformConfig: Address;
+    timeToStake: bigint;
 }
 declare function openMarket(input: OpenMarketParams): OpenMarketInstruction<string>;
 
-interface PauseMarketParams extends BaseInstructionParams {
-    authority: TransactionSigner;
+interface PauseStakingParams extends BaseInstructionParams {
+    marketAuthority: TransactionSigner;
+    market: Address;
+}
+declare function pauseStaking(input: PauseStakingParams): PauseStakingInstruction<string>;
+
+interface ResumeStakingParams extends BaseInstructionParams {
+    marketAuthority: TransactionSigner;
     market: Address;
 }
-declare function pauseMarket(input: PauseMarketParams): PauseMarketInstruction<string>;
+declare function resumeStaking(input: ResumeStakingParams): ResumeStakingInstruction<string>;
 
-interface ResumeMarketParams extends BaseInstructionParams {
-    authority: TransactionSigner;
+interface SetWinningOptionParams extends BaseInstructionParams {
+    marketAuthority: TransactionSigner;
     market: Address;
+    optionId: number | bigint;
+    rewardPercentageBp: number;
 }
-declare function resumeMarket(input: ResumeMarketParams): ResumeMarketInstruction<string>;
+declare function setWinningOption(input: SetWinningOptionParams): Promise<SetWinningOptionInstruction<string>>;
 
-interface SelectWinningOptionsParams extends BaseInstructionParams {
-    authority: TransactionSigner;
+interface ResolveMarketParams extends BaseInstructionParams {
+    marketAuthority: TransactionSigner;
     market: Address;
-    selections: Array<WinningOptionArgs>;
 }
-declare function selectWinningOptions(input: SelectWinningOptionsParams): SelectWinningOptionsInstruction<string>;
+declare function resolveMarket(input: ResolveMarketParams): ResolveMarketInstruction<string>;
 
 interface EndRevealPeriodParams extends BaseInstructionParams {
-    authority: TransactionSigner;
+    signer: TransactionSigner;
     market: Address;
 }
 declare function endRevealPeriod(input: EndRevealPeriodParams): EndRevealPeriodInstruction<string>;
@@ -4126,13 +3939,20 @@ interface AddRewardParams extends BaseInstructionParams {
 declare function addReward(input: AddRewardParams): Promise<AddRewardInstruction<string>>;
 
 interface InitStakeAccountParams extends BaseInstructionParams {
-    signer: TransactionSigner;
+    payer: TransactionSigner;
+    owner: Address;
     market: Address;
-    stateNonce: bigint;
     stakeAccountId: number;
 }
 declare function initStakeAccount(input: InitStakeAccountParams): Promise<InitStakeAccountInstruction<string>>;
 
+interface InitAllowedMintParams extends BaseInstructionParams {
+    updateAuthority: TransactionSigner;
+    platformConfig: Address;
+    tokenMint: Address;
+}
+declare function initAllowedMint(input: InitAllowedMintParams): Promise<InitAllowedMintInstruction<string>>;
+
 interface CloseStakeAccountParams extends BaseInstructionParams {
     owner: TransactionSigner;
     market: Address;
@@ -4154,52 +3974,79 @@ interface CloseStuckStakeAccountParams extends BaseInstructionParams {
 }
 declare function closeStuckStakeAccount(input: CloseStuckStakeAccountParams): Promise<CloseStuckStakeAccountInstruction<string>>;
 
-interface ReclaimStakeParams extends BaseInstructionParams {
+interface CloseOptionAccountParams extends BaseInstructionParams {
+    signer: TransactionSigner;
+    creator: Address;
+    market: Address;
+    optionId: number | bigint;
+}
+declare function closeOptionAccount(input: CloseOptionAccountParams): Promise<CloseOptionAccountInstruction<string>>;
+
+interface UnstakeParams extends BaseInstructionParams {
     signer: TransactionSigner;
     owner: Address;
     market: Address;
     tokenMint: Address;
-    marketTokenAta: Address;
     ownerTokenAccount: Address;
     tokenProgram: Address;
     stakeAccountId: number;
 }
-declare function reclaimStake(input: ReclaimStakeParams): Promise<ReclaimStakeInstruction<string>>;
+declare function unstake(input: UnstakeParams): Promise<UnstakeInstruction<string>>;
 
-interface IncrementOptionTallyParams extends BaseInstructionParams {
+interface FinalizeRevealStakeParams extends BaseInstructionParams {
     signer: TransactionSigner;
     owner: Address;
     market: Address;
     optionId: number | bigint;
     stakeAccountId: number;
 }
-declare function incrementOptionTally(input: IncrementOptionTallyParams): Promise<IncrementOptionTallyInstruction<string>>;
+declare function finalizeRevealStake(input: FinalizeRevealStakeParams): Promise<FinalizeRevealStakeInstruction<string>>;
 
-interface UnstakeEarlyParams extends BaseInstructionParams {
+interface CreatePlatformConfigParams extends BaseInstructionParams {
     signer: TransactionSigner;
-    market: Address;
-    stakeAccountId: number;
+    name: string;
+    platformFeeBp: number;
+    rewardPoolFeeBp: number;
+    creatorFeeBp: number;
+    feeClaimAuthority: Address;
+    minTimeToStakeSeconds: bigint;
+    minRevealPeriodSeconds: bigint;
+    maxRevealPeriodSeconds: bigint;
+    marketResolutionDeadlineSeconds: bigint;
 }
-declare function unstakeEarly(input: UnstakeEarlyParams): Promise<UnstakeEarlyInstruction<string>>;
+declare function createPlatformConfig(rpc: Parameters<typeof fetchMaybePlatformConfig>[0], params: CreatePlatformConfigParams): Promise<Instruction>;
 
-interface DoUnstakeEarlyParams extends BaseInstructionParams {
+interface UpdatePlatformConfigParams extends BaseInstructionParams {
+    signer: TransactionSigner;
+    name: string;
+    platformFeeBp: number;
+    rewardPoolFeeBp: number;
+    creatorFeeBp: number;
+    minTimeToStakeSeconds: bigint;
+    minRevealPeriodSeconds: bigint;
+    maxRevealPeriodSeconds: bigint;
+    marketResolutionDeadlineSeconds: bigint;
+}
+declare function updatePlatformConfig(rpc: Parameters<typeof fetchMaybePlatformConfig>[0], params: UpdatePlatformConfigParams): Promise<Instruction>;
+
+interface ClaimFeesParams extends BaseInstructionParams {
     signer: TransactionSigner;
     market: Address;
+    platformConfig: Address;
     tokenMint: Address;
-    marketTokenAta: Address;
-    ownerTokenAccount: Address;
+    destinationTokenAccount: Address;
     tokenProgram: Address;
-    stakeAccountId: number;
-    stakeAccountOwner: Address;
 }
-declare function doUnstakeEarly(input: DoUnstakeEarlyParams): Promise<DoUnstakeEarlyInstruction<string>>;
+declare function claimFees(input: ClaimFeesParams): Promise<ClaimFeesInstruction<string>>;
 
-interface EnsureCentralStateParams extends BaseInstructionParams {
+interface ClaimCreatorFeesParams extends BaseInstructionParams {
     signer: TransactionSigner;
-    protocolFeeBp: number;
-    feeClaimer: Address;
+    market: Address;
+    tokenMint: Address;
+    destinationTokenAccount: Address;
+    tokenProgram: Address;
 }
-declare function ensureCentralState(rpc: Parameters<typeof fetchMaybeCentralState>[0], params: EnsureCentralStateParams): Promise<Instruction | null>;
+declare function claimCreatorFees(input: ClaimCreatorFeesParams): Promise<ClaimCreatorFeesInstruction<string>>;
 
 interface WithdrawRewardParams extends BaseInstructionParams {
     sponsor: TransactionSigner;
@@ -4210,45 +4057,28 @@ interface WithdrawRewardParams extends BaseInstructionParams {
 }
 declare function withdrawReward(input: WithdrawRewardParams): Promise<WithdrawRewardInstruction<string>>;
 
-interface ProposeNewUpdateAuthorityParams extends BaseInstructionParams {
-    updateAuthority: TransactionSigner;
-    proposedAuthority: Address;
-}
-declare function proposeNewUpdateAuthority(input: ProposeNewUpdateAuthorityParams): Promise<ProposeNewUpdateAuthorityInstruction<string>>;
-
-interface ProposeNewFeeClaimerParams extends BaseInstructionParams {
-    updateAuthority: TransactionSigner;
-    proposedFeeClaimer: Address;
-}
-declare function proposeNewFeeClaimer(input: ProposeNewFeeClaimerParams): Promise<ProposeNewFeeClaimerInstruction<string>>;
-
-interface FinalizeNewUpdateAuthorityParams extends BaseInstructionParams {
+interface SetUpdateAuthorityParams extends BaseInstructionParams {
     updateAuthority: TransactionSigner;
-    proposedAuthority: TransactionSigner;
+    platformConfig: Address;
+    newAuthority: Address;
 }
-declare function finalizeNewUpdateAuthority(input: FinalizeNewUpdateAuthorityParams): Promise<FinalizeNewUpdateAuthorityInstruction<string>>;
+declare function setUpdateAuthority(input: SetUpdateAuthorityParams): SetUpdateAuthorityInstruction<string>;
 
-interface FinalizeNewFeeClaimerParams extends BaseInstructionParams {
+interface SetFeeClaimAuthorityParams extends BaseInstructionParams {
     updateAuthority: TransactionSigner;
-    proposedFeeClaimer: TransactionSigner;
-}
-declare function finalizeNewFeeClaimer(input: FinalizeNewFeeClaimerParams): Promise<FinalizeNewFeeClaimerInstruction<string>>;
-
-interface CancelUpdateAuthorityChangeParams extends BaseInstructionParams {
-    signer: TransactionSigner;
+    platformConfig: Address;
+    newFeeClaimAuthority: Address;
 }
-declare function cancelUpdateAuthorityChange(input: CancelUpdateAuthorityChangeParams): Promise<CancelUpdateAuthorityChangeInstruction<string>>;
+declare function setFeeClaimAuthority(input: SetFeeClaimAuthorityParams): SetFeeClaimAuthorityInstruction<string>;
 
-interface CancelFeeClaimerChangeParams extends BaseInstructionParams {
-    signer: TransactionSigner;
-}
-declare function cancelFeeClaimerChange(input: CancelFeeClaimerChangeParams): Promise<CancelFeeClaimerChangeInstruction<string>>;
+declare const PLATFORM_CONFIG_SEED = "platform_config";
+declare function getPlatformConfigAddress(authority: Address, name: string, programId?: Address): Promise<ProgramDerivedAddress>;
 
-declare const CENTRAL_STATE_SEED = "central_state";
-declare function getCentralStateAddress(programId?: Address): Promise<ProgramDerivedAddress>;
+declare const ALLOWED_MINT_SEED = "allowed_mint";
+declare function getAllowedMintAddress(platformConfig: Address, mint: Address, programId?: Address): Promise<ProgramDerivedAddress>;
 
 declare const OPPORTUNITY_MARKET_SEED = "opportunity_market";
-declare function getOpportunityMarketAddress(creator: Address, marketIndex: bigint | number, programId?: Address): Promise<ProgramDerivedAddress>;
+declare function getOpportunityMarketAddress(platformConfig: Address, creator: Address, marketIndex: bigint | number, programId?: Address): Promise<ProgramDerivedAddress>;
 
 declare const OPPORTUNITY_MARKET_OPTION_SEED = "option";
 declare function getOpportunityMarketOptionAddress(market: Address, optionId: number | bigint, programId?: Address): Promise<ProgramDerivedAddress>;
@@ -4259,9 +4089,6 @@ declare function getOpportunityMarketSponsorAddress(sponsor: Address, market: Ad
 declare const STAKE_ACCOUNT_SEED = "stake_account";
 declare function getStakeAccountAddress(owner: Address, market: Address, stakeAccountId: number, programId?: Address): Promise<ProgramDerivedAddress>;
 
-declare const TOKEN_VAULT_SEED = "token_vault";
-declare function getTokenVaultAddress(mint: Address, programId?: Address): Promise<ProgramDerivedAddress>;
-
 interface AwaitComputationOptions {
     commitment?: "processed" | "confirmed" | "finalized";
     mxeProgramId?: Address;
@@ -4310,4 +4137,4 @@ declare function deriveSharedSecret(userSecretKey: Uint8Array, mxePublicKey: Uin
 declare function createCipher(userSecretKey: Uint8Array, mxePublicKey: Uint8Array): RescueCipher;
 declare function nonceToBytes(nonce: bigint): Uint8Array;
 
-export { ADD_MARKET_OPTION_DISCRIMINATOR, ADD_REWARD_DISCRIMINATOR, ALL_COMP_DEF_CIRCUITS, ARCIUM_SIGNER_ACCOUNT_DISCRIMINATOR, type AccountChangeCancelledEvent, type AccountChangeCancelledEventArgs, type AccountChangeFinalizedEvent, type AccountChangeFinalizedEventArgs, type AccountChangeProposedEvent, type AccountChangeProposedEventArgs, type Activation, type ActivationArgs, type AddMarketOptionAsyncInput, type AddMarketOptionInput, type AddMarketOptionInstruction, type AddMarketOptionInstructionData, type AddMarketOptionInstructionDataArgs, type AddMarketOptionParams, type AddRewardAsyncInput, type AddRewardInput, type AddRewardInstruction, type AddRewardInstructionData, type AddRewardInstructionDataArgs, type AddRewardParams, type ArciumSignerAccount, type ArciumSignerAccountArgs, type AwaitComputationOptions, type BN254G2BLSPublicKey, type BN254G2BLSPublicKeyArgs, type BaseInstructionParams, type ByteArray, CANCEL_FEE_CLAIMER_CHANGE_DISCRIMINATOR, CANCEL_UPDATE_AUTHORITY_CHANGE_DISCRIMINATOR, CENTRAL_STATE_DISCRIMINATOR, CENTRAL_STATE_SEED, CLAIM_FEES_DISCRIMINATOR, CLOCK_ACCOUNT_DISCRIMINATOR, CLOSE_STAKE_ACCOUNT_DISCRIMINATOR, CLOSE_STUCK_STAKE_ACCOUNT_DISCRIMINATOR, CLUSTER_DISCRIMINATOR, COMPUTATION_DEFINITION_ACCOUNT_DISCRIMINATOR, CREATE_MARKET_DISCRIMINATOR, type CancelFeeClaimerChangeAsyncInput, type CancelFeeClaimerChangeInput, type CancelFeeClaimerChangeInstruction, type CancelFeeClaimerChangeInstructionData, type CancelFeeClaimerChangeInstructionDataArgs, type CancelFeeClaimerChangeParams, type CancelUpdateAuthorityChangeAsyncInput, type CancelUpdateAuthorityChangeInput, type CancelUpdateAuthorityChangeInstruction, type CancelUpdateAuthorityChangeInstructionData, type CancelUpdateAuthorityChangeInstructionDataArgs, type CancelUpdateAuthorityChangeParams, type CentralState, type CentralStateArgs, type CircuitSource, type CircuitSourceArgs, type ClaimFeesAsyncInput, type ClaimFeesInput, type ClaimFeesInstruction, type ClaimFeesInstructionData, type ClaimFeesInstructionDataArgs, type ClockAccount, type ClockAccountArgs, type CloseStakeAccountAsyncInput, type CloseStakeAccountInput, type CloseStakeAccountInstruction, type CloseStakeAccountInstructionData, type CloseStakeAccountInstructionDataArgs, type CloseStakeAccountParams, type CloseStuckStakeAccountAsyncInput, type CloseStuckStakeAccountInput, type CloseStuckStakeAccountInstruction, type CloseStuckStakeAccountInstructionData, type CloseStuckStakeAccountInstructionDataArgs, type CloseStuckStakeAccountParams, type Cluster, type ClusterArgs, type CompDefCircuitName, type ComputationDefinitionAccount, type ComputationDefinitionAccountArgs, type ComputationDefinitionMeta, type ComputationDefinitionMetaArgs, type ComputationResult, type ComputationSignature, type ComputationSignatureArgs, type CreateMarketAsyncInput, type CreateMarketInput, type CreateMarketInstruction, type CreateMarketInstructionData, type CreateMarketInstructionDataArgs, type CreateMarketParams, DO_UNSTAKE_EARLY_DISCRIMINATOR, type DoUnstakeEarlyAsyncInput, type DoUnstakeEarlyInput, type DoUnstakeEarlyInstruction, type DoUnstakeEarlyInstructionData, type DoUnstakeEarlyInstructionDataArgs, type DoUnstakeEarlyParams, END_REVEAL_PERIOD_DISCRIMINATOR, type EndRevealPeriodInput, type EndRevealPeriodInstruction, type EndRevealPeriodInstructionData, type EndRevealPeriodInstructionDataArgs, type EndRevealPeriodParams, type EnsureCentralStateParams, type Epoch, type EpochArgs, FEE_POOL_DISCRIMINATOR, FINALIZE_NEW_FEE_CLAIMER_DISCRIMINATOR, FINALIZE_NEW_UPDATE_AUTHORITY_DISCRIMINATOR, type FeePool, type FeePoolArgs, type FeesClaimedEvent, type FeesClaimedEventArgs, type FinalizeNewFeeClaimerAsyncInput, type FinalizeNewFeeClaimerInput, type FinalizeNewFeeClaimerInstruction, type FinalizeNewFeeClaimerInstructionData, type FinalizeNewFeeClaimerInstructionDataArgs, type FinalizeNewFeeClaimerParams, type FinalizeNewUpdateAuthorityAsyncInput, type FinalizeNewUpdateAuthorityInput, type FinalizeNewUpdateAuthorityInstruction, type FinalizeNewUpdateAuthorityInstructionData, type FinalizeNewUpdateAuthorityInstructionDataArgs, type FinalizeNewUpdateAuthorityParams, INCREMENT_OPTION_TALLY_DISCRIMINATOR, INIT_CENTRAL_STATE_DISCRIMINATOR, INIT_STAKE_ACCOUNT_DISCRIMINATOR, INIT_TOKEN_VAULT_DISCRIMINATOR, type IncrementOptionTallyAsyncInput, type IncrementOptionTallyInput, type IncrementOptionTallyInstruction, type IncrementOptionTallyInstructionData, type IncrementOptionTallyInstructionDataArgs, type IncrementOptionTallyParams, type InitCentralStateAsyncInput, type InitCentralStateInput, type InitCentralStateInstruction, type InitCentralStateInstructionData, type InitCentralStateInstructionDataArgs, type InitCompDefConfig, type InitStakeAccountAsyncInput, type InitStakeAccountInput, type InitStakeAccountInstruction, type InitStakeAccountInstructionData, type InitStakeAccountInstructionDataArgs, type InitStakeAccountParams, type InitTokenVaultAsyncInput, type InitTokenVaultInput, type InitTokenVaultInstruction, type InitTokenVaultInstructionData, type InitTokenVaultInstructionDataArgs, type InitTokenVaultParams, LocalCircuitSource, type LocalCircuitSourceArgs, type MXEAccount, type MXEAccountArgs, M_X_E_ACCOUNT_DISCRIMINATOR, type MarketCreatedEvent, type MarketCreatedEventArgs, type MarketOpenedEvent, type MarketOpenedEventArgs, type MarketOptionCreatedEvent, type MarketOptionCreatedEventArgs, type MarketPausedEvent, type MarketPausedEventArgs, type MarketResumedEvent, type MarketResumedEventArgs, MxeStatus, type MxeStatusArgs, type NodeMetadata, type NodeMetadataArgs, type NodeRef, type NodeRefArgs, OPEN_MARKET_DISCRIMINATOR, OPPORTUNITY_MARKET_DISCRIMINATOR, OPPORTUNITY_MARKET_ERROR__ABORTED_COMPUTATION, OPPORTUNITY_MARKET_ERROR__ADD_OPTION_STAKE_FAILED, OPPORTUNITY_MARKET_ERROR__ALREADY_REVEALED, OPPORTUNITY_MARKET_ERROR__ALREADY_STAKED, OPPORTUNITY_MARKET_ERROR__ALREADY_UNSTAKED, OPPORTUNITY_MARKET_ERROR__CLOSING_EARLY_NOT_ALLOWED, OPPORTUNITY_MARKET_ERROR__CLUSTER_NOT_SET, OPPORTUNITY_MARKET_ERROR__DEPOSIT_BELOW_MINIMUM, OPPORTUNITY_MARKET_ERROR__EARLINESS_CUTOFF_TOO_LARGE, OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_BALANCE, OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_REWARD_FUNDING, OPPORTUNITY_MARKET_ERROR__INVALID_ACCOUNT_STATE, OPPORTUNITY_MARKET_ERROR__INVALID_MINT, OPPORTUNITY_MARKET_ERROR__INVALID_OPTION_ID, OPPORTUNITY_MARKET_ERROR__INVALID_TIMESTAMP, OPPORTUNITY_MARKET_ERROR__INVALID_WINNING_OPTIONS_INPUT, OPPORTUNITY_MARKET_ERROR__LOCKED, OPPORTUNITY_MARKET_ERROR__MARKET_ALREADY_OPEN, OPPORTUNITY_MARKET_ERROR__MARKET_NOT_OPEN, OPPORTUNITY_MARKET_ERROR__MARKET_NOT_PAUSED, OPPORTUNITY_MARKET_ERROR__MARKET_NOT_RESOLVED, OPPORTUNITY_MARKET_ERROR__MARKET_PAUSED, OPPORTUNITY_MARKET_ERROR__NOT_REVEALED, OPPORTUNITY_MARKET_ERROR__NO_FEES_TO_CLAIM, OPPORTUNITY_MARKET_ERROR__OVERFLOW, OPPORTUNITY_MARKET_ERROR__PROTOCOL_FEE_TOO_HIGH, OPPORTUNITY_MARKET_ERROR__REVEAL_PERIOD_ENDED, OPPORTUNITY_MARKET_ERROR__STAKE_NOT_STUCK, OPPORTUNITY_MARKET_ERROR__STAKING_NOT_ACTIVE, OPPORTUNITY_MARKET_ERROR__TALLY_ALREADY_INCREMENTED, OPPORTUNITY_MARKET_ERROR__TIMELOCK_NOT_ELAPSED, OPPORTUNITY_MARKET_ERROR__UNAUTHORIZED, OPPORTUNITY_MARKET_ERROR__UNSTAKE_DELAY_NOT_MET, OPPORTUNITY_MARKET_ERROR__UNSTAKE_NOT_INITIATED, OPPORTUNITY_MARKET_ERROR__WINNER_ALREADY_SELECTED, OPPORTUNITY_MARKET_OPTION_DISCRIMINATOR, OPPORTUNITY_MARKET_OPTION_SEED, OPPORTUNITY_MARKET_PROGRAM_ADDRESS, OPPORTUNITY_MARKET_SEED, OPPORTUNITY_MARKET_SPONSOR_DISCRIMINATOR, type OffChainCircuitSource, type OffChainCircuitSourceArgs, type OnChainCircuitSource, type OnChainCircuitSourceArgs, type OpenMarketInput, type OpenMarketInstruction, type OpenMarketInstructionData, type OpenMarketInstructionDataArgs, type OpenMarketParams, type OpportunityMarket, OpportunityMarketAccount, type OpportunityMarketArgs, type OpportunityMarketError, OpportunityMarketInstruction, type OpportunityMarketOption, type OpportunityMarketOptionArgs, type OpportunityMarketSponsor, type OpportunityMarketSponsorArgs, Output, type OutputArgs, PAUSE_MARKET_DISCRIMINATOR, PROPOSE_NEW_FEE_CLAIMER_DISCRIMINATOR, PROPOSE_NEW_UPDATE_AUTHORITY_DISCRIMINATOR, Parameter, type ParameterArgs, type ParsedAddMarketOptionInstruction, type ParsedAddRewardInstruction, type ParsedCancelFeeClaimerChangeInstruction, type ParsedCancelUpdateAuthorityChangeInstruction, type ParsedClaimFeesInstruction, type ParsedCloseStakeAccountInstruction, type ParsedCloseStuckStakeAccountInstruction, type ParsedCreateMarketInstruction, type ParsedDoUnstakeEarlyInstruction, type ParsedEndRevealPeriodInstruction, type ParsedFinalizeNewFeeClaimerInstruction, type ParsedFinalizeNewUpdateAuthorityInstruction, type ParsedIncrementOptionTallyInstruction, type ParsedInitCentralStateInstruction, type ParsedInitStakeAccountInstruction, type ParsedInitTokenVaultInstruction, type ParsedOpenMarketInstruction, type ParsedOpportunityMarketInstruction, type ParsedPauseMarketInstruction, type ParsedProposeNewFeeClaimerInstruction, type ParsedProposeNewUpdateAuthorityInstruction, type ParsedReclaimStakeInstruction, type ParsedResumeMarketInstruction, type ParsedRevealStakeCallbackInstruction, type ParsedRevealStakeCompDefInstruction, type ParsedRevealStakeInstruction, type ParsedSelectWinningOptionsInstruction, type ParsedStakeCallbackInstruction, type ParsedStakeCompDefInstruction, type ParsedStakeInstruction, type ParsedUnstakeEarlyInstruction, type ParsedUpdateCentralStateInstruction, type ParsedWithdrawRewardInstruction, type PauseMarketInput, type PauseMarketInstruction, type PauseMarketInstructionData, type PauseMarketInstructionDataArgs, type PauseMarketParams, type ProposeNewFeeClaimerAsyncInput, type ProposeNewFeeClaimerInput, type ProposeNewFeeClaimerInstruction, type ProposeNewFeeClaimerInstructionData, type ProposeNewFeeClaimerInstructionDataArgs, type ProposeNewFeeClaimerParams, type ProposeNewUpdateAuthorityAsyncInput, type ProposeNewUpdateAuthorityInput, type ProposeNewUpdateAuthorityInstruction, type ProposeNewUpdateAuthorityInstructionData, type ProposeNewUpdateAuthorityInstructionDataArgs, type ProposeNewUpdateAuthorityParams, RECLAIM_STAKE_DISCRIMINATOR, RESUME_MARKET_DISCRIMINATOR, REVEAL_STAKE_CALLBACK_DISCRIMINATOR, REVEAL_STAKE_COMP_DEF_DISCRIMINATOR, REVEAL_STAKE_DISCRIMINATOR, type ReclaimStakeAsyncInput, type ReclaimStakeInput, type ReclaimStakeInstruction, type ReclaimStakeInstructionData, type ReclaimStakeInstructionDataArgs, type ReclaimStakeParams, type ResumeMarketInput, type ResumeMarketInstruction, type ResumeMarketInstructionData, type ResumeMarketInstructionDataArgs, type ResumeMarketParams, type RevealPeriodEndedEvent, type RevealPeriodEndedEventArgs, type RevealStakeAsyncInput, type RevealStakeCallbackInput, type RevealStakeCallbackInstruction, type RevealStakeCallbackInstructionData, type RevealStakeCallbackInstructionDataArgs, type RevealStakeCompDefInput, type RevealStakeCompDefInstruction, type RevealStakeCompDefInstructionData, type RevealStakeCompDefInstructionDataArgs, type RevealStakeInput, type RevealStakeInstruction, type RevealStakeInstructionData, type RevealStakeInstructionDataArgs, type RevealStakeOutput, type RevealStakeOutputArgs, type RevealStakeParams, type RewardAddedEvent, type RewardAddedEventArgs, type RewardClaimedEvent, type RewardClaimedEventArgs, type RewardWithdrawnEvent, type RewardWithdrawnEventArgs, SELECT_WINNING_OPTIONS_DISCRIMINATOR, SPONSOR_SEED, STAKE_ACCOUNT_DISCRIMINATOR, STAKE_ACCOUNT_SEED, STAKE_CALLBACK_DISCRIMINATOR, STAKE_COMP_DEF_DISCRIMINATOR, STAKE_DISCRIMINATOR, type SelectWinningOptionsInput, type SelectWinningOptionsInstruction, type SelectWinningOptionsInstructionData, type SelectWinningOptionsInstructionDataArgs, type SelectWinningOptionsParams, type StakeAccount, type StakeAccountArgs, type StakeAccountInitializedEvent, type StakeAccountInitializedEventArgs, type StakeAsyncInput, type StakeCallbackInput, type StakeCallbackInstruction, type StakeCallbackInstructionData, type StakeCallbackInstructionDataArgs, type StakeCompDefInput, type StakeCompDefInstruction, type StakeCompDefInstructionData, type StakeCompDefInstructionDataArgs, type StakeInput, type StakeInstruction, type StakeInstructionData, type StakeInstructionDataArgs, type StakeOutput, type StakeOutputArgs, type StakeOutputStruct0, type StakeOutputStruct0Args, type StakeParams, type StakeReclaimedEvent, type StakeReclaimedEventArgs, type StakeRevealedEvent, type StakeRevealedEventArgs, type StakedEvent, type StakedEventArgs, type StuckStakeClosedEvent, type StuckStakeClosedEventArgs, TIMELOCKED_ACCOUNT_CHANGE_DISCRIMINATOR, TOKEN_VAULT_DISCRIMINATOR, TOKEN_VAULT_SEED, type TallyIncrementedEvent, type TallyIncrementedEventArgs, type TimelockedAccountChange, type TimelockedAccountChangeArgs, type Timestamp, type TimestampArgs, type TokenVault, type TokenVaultArgs, UNSTAKE_EARLY_DISCRIMINATOR, UPDATE_CENTRAL_STATE_DISCRIMINATOR, type UnstakeEarlyAsyncInput, type UnstakeEarlyInput, type UnstakeEarlyInstruction, type UnstakeEarlyInstructionData, type UnstakeEarlyInstructionDataArgs, type UnstakeEarlyParams, type UnstakeInitiatedEvent, type UnstakeInitiatedEventArgs, type UnstakedEvent, type UnstakedEventArgs, type UpdateCentralStateAsyncInput, type UpdateCentralStateInput, type UpdateCentralStateInstruction, type UpdateCentralStateInstructionData, type UpdateCentralStateInstructionDataArgs, type UtilityPubkeys, type UtilityPubkeysArgs, WITHDRAW_REWARD_DISCRIMINATOR, type WinningOption, type WinningOptionArgs, type WinningOptionsSelectedEvent, type WinningOptionsSelectedEventArgs, type WithdrawRewardAsyncInput, type WithdrawRewardInput, type WithdrawRewardInstruction, type WithdrawRewardInstructionData, type WithdrawRewardInstructionDataArgs, type WithdrawRewardParams, type X25519Keypair, addMarketOption, addReward, awaitBatchComputationFinalization, awaitComputationFinalization, cancelFeeClaimerChange, cancelUpdateAuthorityChange, circuitSource, closeStakeAccount, closeStuckStakeAccount, createCipher, createMarket, decodeArciumSignerAccount, decodeCentralState, decodeClockAccount, decodeCluster, decodeComputationDefinitionAccount, decodeFeePool, decodeMXEAccount, decodeOpportunityMarket, decodeOpportunityMarketOption, decodeOpportunityMarketSponsor, decodeStakeAccount, decodeTimelockedAccountChange, decodeTokenVault, deriveSharedSecret, deriveX25519KeypairFromSignature, doUnstakeEarly, endRevealPeriod, ensureCentralState, fetchAllArciumSignerAccount, fetchAllCentralState, fetchAllClockAccount, fetchAllCluster, fetchAllComputationDefinitionAccount, fetchAllFeePool, fetchAllMXEAccount, fetchAllMaybeArciumSignerAccount, fetchAllMaybeCentralState, fetchAllMaybeClockAccount, fetchAllMaybeCluster, fetchAllMaybeComputationDefinitionAccount, fetchAllMaybeFeePool, fetchAllMaybeMXEAccount, fetchAllMaybeOpportunityMarket, fetchAllMaybeOpportunityMarketOption, fetchAllMaybeOpportunityMarketSponsor, fetchAllMaybeStakeAccount, fetchAllMaybeTimelockedAccountChange, fetchAllMaybeTokenVault, fetchAllOpportunityMarket, fetchAllOpportunityMarketOption, fetchAllOpportunityMarketSponsor, fetchAllStakeAccount, fetchAllTimelockedAccountChange, fetchAllTokenVault, fetchArciumSignerAccount, fetchCentralState, fetchClockAccount, fetchCluster, fetchComputationDefinitionAccount, fetchFeePool, fetchMXEAccount, fetchMaybeArciumSignerAccount, fetchMaybeCentralState, fetchMaybeClockAccount, fetchMaybeCluster, fetchMaybeComputationDefinitionAccount, fetchMaybeFeePool, fetchMaybeMXEAccount, fetchMaybeOpportunityMarket, fetchMaybeOpportunityMarketOption, fetchMaybeOpportunityMarketSponsor, fetchMaybeStakeAccount, fetchMaybeTimelockedAccountChange, fetchMaybeTokenVault, fetchOpportunityMarket, fetchOpportunityMarketOption, fetchOpportunityMarketSponsor, fetchStakeAccount, fetchTimelockedAccountChange, fetchTokenVault, finalizeNewFeeClaimer, finalizeNewUpdateAuthority, generateX25519Keypair, getAccountChangeCancelledEventCodec, getAccountChangeCancelledEventDecoder, getAccountChangeCancelledEventEncoder, getAccountChangeFinalizedEventCodec, getAccountChangeFinalizedEventDecoder, getAccountChangeFinalizedEventEncoder, getAccountChangeProposedEventCodec, getAccountChangeProposedEventDecoder, getAccountChangeProposedEventEncoder, getActivationCodec, getActivationDecoder, getActivationEncoder, getAddMarketOptionDiscriminatorBytes, getAddMarketOptionInstruction, getAddMarketOptionInstructionAsync, getAddMarketOptionInstructionDataCodec, getAddMarketOptionInstructionDataDecoder, getAddMarketOptionInstructionDataEncoder, getAddRewardDiscriminatorBytes, getAddRewardInstruction, getAddRewardInstructionAsync, getAddRewardInstructionDataCodec, getAddRewardInstructionDataDecoder, getAddRewardInstructionDataEncoder, getArciumSignerAccountCodec, getArciumSignerAccountDecoder, getArciumSignerAccountDiscriminatorBytes, getArciumSignerAccountEncoder, getBN254G2BLSPublicKeyCodec, getBN254G2BLSPublicKeyDecoder, getBN254G2BLSPublicKeyEncoder, getCancelFeeClaimerChangeDiscriminatorBytes, getCancelFeeClaimerChangeInstruction, getCancelFeeClaimerChangeInstructionAsync, getCancelFeeClaimerChangeInstructionDataCodec, getCancelFeeClaimerChangeInstructionDataDecoder, getCancelFeeClaimerChangeInstructionDataEncoder, getCancelUpdateAuthorityChangeDiscriminatorBytes, getCancelUpdateAuthorityChangeInstruction, getCancelUpdateAuthorityChangeInstructionAsync, getCancelUpdateAuthorityChangeInstructionDataCodec, getCancelUpdateAuthorityChangeInstructionDataDecoder, getCancelUpdateAuthorityChangeInstructionDataEncoder, getCentralStateAddress, getCentralStateCodec, getCentralStateDecoder, getCentralStateDiscriminatorBytes, getCentralStateEncoder, getCircuitSourceCodec, getCircuitSourceDecoder, getCircuitSourceEncoder, getClaimFeesDiscriminatorBytes, getClaimFeesInstruction, getClaimFeesInstructionAsync, getClaimFeesInstructionDataCodec, getClaimFeesInstructionDataDecoder, getClaimFeesInstructionDataEncoder, getClockAccountCodec, getClockAccountDecoder, getClockAccountDiscriminatorBytes, getClockAccountEncoder, getCloseStakeAccountDiscriminatorBytes, getCloseStakeAccountInstruction, getCloseStakeAccountInstructionAsync, getCloseStakeAccountInstructionDataCodec, getCloseStakeAccountInstructionDataDecoder, getCloseStakeAccountInstructionDataEncoder, getCloseStuckStakeAccountDiscriminatorBytes, getCloseStuckStakeAccountInstruction, getCloseStuckStakeAccountInstructionAsync, getCloseStuckStakeAccountInstructionDataCodec, getCloseStuckStakeAccountInstructionDataDecoder, getCloseStuckStakeAccountInstructionDataEncoder, getClusterCodec, getClusterDecoder, getClusterDiscriminatorBytes, getClusterEncoder, getCompDefAccount, getCompDefOffsetNumber, getComputationDefinitionAccountCodec, getComputationDefinitionAccountDecoder, getComputationDefinitionAccountDiscriminatorBytes, getComputationDefinitionAccountEncoder, getComputationDefinitionMetaCodec, getComputationDefinitionMetaDecoder, getComputationDefinitionMetaEncoder, getComputationSignatureCodec, getComputationSignatureDecoder, getComputationSignatureEncoder, getCreateMarketDiscriminatorBytes, getCreateMarketInstruction, getCreateMarketInstructionAsync, getCreateMarketInstructionDataCodec, getCreateMarketInstructionDataDecoder, getCreateMarketInstructionDataEncoder, getDoUnstakeEarlyDiscriminatorBytes, getDoUnstakeEarlyInstruction, getDoUnstakeEarlyInstructionAsync, getDoUnstakeEarlyInstructionDataCodec, getDoUnstakeEarlyInstructionDataDecoder, getDoUnstakeEarlyInstructionDataEncoder, getEndRevealPeriodDiscriminatorBytes, getEndRevealPeriodInstruction, getEndRevealPeriodInstructionDataCodec, getEndRevealPeriodInstructionDataDecoder, getEndRevealPeriodInstructionDataEncoder, getEpochCodec, getEpochDecoder, getEpochEncoder, getFeePoolCodec, getFeePoolDecoder, getFeePoolDiscriminatorBytes, getFeePoolEncoder, getFeesClaimedEventCodec, getFeesClaimedEventDecoder, getFeesClaimedEventEncoder, getFinalizeNewFeeClaimerDiscriminatorBytes, getFinalizeNewFeeClaimerInstruction, getFinalizeNewFeeClaimerInstructionAsync, getFinalizeNewFeeClaimerInstructionDataCodec, getFinalizeNewFeeClaimerInstructionDataDecoder, getFinalizeNewFeeClaimerInstructionDataEncoder, getFinalizeNewUpdateAuthorityDiscriminatorBytes, getFinalizeNewUpdateAuthorityInstruction, getFinalizeNewUpdateAuthorityInstructionAsync, getFinalizeNewUpdateAuthorityInstructionDataCodec, getFinalizeNewUpdateAuthorityInstructionDataDecoder, getFinalizeNewUpdateAuthorityInstructionDataEncoder, getIncrementOptionTallyDiscriminatorBytes, getIncrementOptionTallyInstruction, getIncrementOptionTallyInstructionAsync, getIncrementOptionTallyInstructionDataCodec, getIncrementOptionTallyInstructionDataDecoder, getIncrementOptionTallyInstructionDataEncoder, getInitCentralStateDiscriminatorBytes, getInitCentralStateInstruction, getInitCentralStateInstructionAsync, getInitCentralStateInstructionDataCodec, getInitCentralStateInstructionDataDecoder, getInitCentralStateInstructionDataEncoder, getInitCompDefInstruction, getInitStakeAccountDiscriminatorBytes, getInitStakeAccountInstruction, getInitStakeAccountInstructionAsync, getInitStakeAccountInstructionDataCodec, getInitStakeAccountInstructionDataDecoder, getInitStakeAccountInstructionDataEncoder, getInitTokenVaultDiscriminatorBytes, getInitTokenVaultInstruction, getInitTokenVaultInstructionAsync, getInitTokenVaultInstructionDataCodec, getInitTokenVaultInstructionDataDecoder, getInitTokenVaultInstructionDataEncoder, getLocalCircuitSourceCodec, getLocalCircuitSourceDecoder, getLocalCircuitSourceEncoder, getMXEAccountCodec, getMXEAccountDecoder, getMXEAccountDiscriminatorBytes, getMXEAccountEncoder, getMarketCreatedEventCodec, getMarketCreatedEventDecoder, getMarketCreatedEventEncoder, getMarketOpenedEventCodec, getMarketOpenedEventDecoder, getMarketOpenedEventEncoder, getMarketOptionCreatedEventCodec, getMarketOptionCreatedEventDecoder, getMarketOptionCreatedEventEncoder, getMarketPausedEventCodec, getMarketPausedEventDecoder, getMarketPausedEventEncoder, getMarketResumedEventCodec, getMarketResumedEventDecoder, getMarketResumedEventEncoder, getMxeAccount, getMxeStatusCodec, getMxeStatusDecoder, getMxeStatusEncoder, getNodeMetadataCodec, getNodeMetadataDecoder, getNodeMetadataEncoder, getNodeRefCodec, getNodeRefDecoder, getNodeRefEncoder, getOffChainCircuitSourceCodec, getOffChainCircuitSourceDecoder, getOffChainCircuitSourceEncoder, getOnChainCircuitSourceCodec, getOnChainCircuitSourceDecoder, getOnChainCircuitSourceEncoder, getOpenMarketDiscriminatorBytes, getOpenMarketInstruction, getOpenMarketInstructionDataCodec, getOpenMarketInstructionDataDecoder, getOpenMarketInstructionDataEncoder, getOpportunityMarketAddress, getOpportunityMarketCodec, getOpportunityMarketDecoder, getOpportunityMarketDiscriminatorBytes, getOpportunityMarketEncoder, getOpportunityMarketErrorMessage, getOpportunityMarketOptionAddress, getOpportunityMarketOptionCodec, getOpportunityMarketOptionDecoder, getOpportunityMarketOptionDiscriminatorBytes, getOpportunityMarketOptionEncoder, getOpportunityMarketSponsorAddress, getOpportunityMarketSponsorCodec, getOpportunityMarketSponsorDecoder, getOpportunityMarketSponsorDiscriminatorBytes, getOpportunityMarketSponsorEncoder, getOutputCodec, getOutputDecoder, getOutputEncoder, getParameterCodec, getParameterDecoder, getParameterEncoder, getPauseMarketDiscriminatorBytes, getPauseMarketInstruction, getPauseMarketInstructionDataCodec, getPauseMarketInstructionDataDecoder, getPauseMarketInstructionDataEncoder, getProposeNewFeeClaimerDiscriminatorBytes, getProposeNewFeeClaimerInstruction, getProposeNewFeeClaimerInstructionAsync, getProposeNewFeeClaimerInstructionDataCodec, getProposeNewFeeClaimerInstructionDataDecoder, getProposeNewFeeClaimerInstructionDataEncoder, getProposeNewUpdateAuthorityDiscriminatorBytes, getProposeNewUpdateAuthorityInstruction, getProposeNewUpdateAuthorityInstructionAsync, getProposeNewUpdateAuthorityInstructionDataCodec, getProposeNewUpdateAuthorityInstructionDataDecoder, getProposeNewUpdateAuthorityInstructionDataEncoder, getReclaimStakeDiscriminatorBytes, getReclaimStakeInstruction, getReclaimStakeInstructionAsync, getReclaimStakeInstructionDataCodec, getReclaimStakeInstructionDataDecoder, getReclaimStakeInstructionDataEncoder, getResumeMarketDiscriminatorBytes, getResumeMarketInstruction, getResumeMarketInstructionDataCodec, getResumeMarketInstructionDataDecoder, getResumeMarketInstructionDataEncoder, getRevealPeriodEndedEventCodec, getRevealPeriodEndedEventDecoder, getRevealPeriodEndedEventEncoder, getRevealStakeCallbackDiscriminatorBytes, getRevealStakeCallbackInstruction, getRevealStakeCallbackInstructionDataCodec, getRevealStakeCallbackInstructionDataDecoder, getRevealStakeCallbackInstructionDataEncoder, getRevealStakeCompDefDiscriminatorBytes, getRevealStakeCompDefInstruction, getRevealStakeCompDefInstructionDataCodec, getRevealStakeCompDefInstructionDataDecoder, getRevealStakeCompDefInstructionDataEncoder, getRevealStakeDiscriminatorBytes, getRevealStakeInstruction, getRevealStakeInstructionAsync, getRevealStakeInstructionDataCodec, getRevealStakeInstructionDataDecoder, getRevealStakeInstructionDataEncoder, getRevealStakeOutputCodec, getRevealStakeOutputDecoder, getRevealStakeOutputEncoder, getRewardAddedEventCodec, getRewardAddedEventDecoder, getRewardAddedEventEncoder, getRewardClaimedEventCodec, getRewardClaimedEventDecoder, getRewardClaimedEventEncoder, getRewardWithdrawnEventCodec, getRewardWithdrawnEventDecoder, getRewardWithdrawnEventEncoder, getSelectWinningOptionsDiscriminatorBytes, getSelectWinningOptionsInstruction, getSelectWinningOptionsInstructionDataCodec, getSelectWinningOptionsInstructionDataDecoder, getSelectWinningOptionsInstructionDataEncoder, getStakeAccountAddress, 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, getStakeReclaimedEventCodec, getStakeReclaimedEventDecoder, getStakeReclaimedEventEncoder, getStakeRevealedEventCodec, getStakeRevealedEventDecoder, getStakeRevealedEventEncoder, getStakedEventCodec, getStakedEventDecoder, getStakedEventEncoder, getStuckStakeClosedEventCodec, getStuckStakeClosedEventDecoder, getStuckStakeClosedEventEncoder, getTallyIncrementedEventCodec, getTallyIncrementedEventDecoder, getTallyIncrementedEventEncoder, getTimelockedAccountChangeCodec, getTimelockedAccountChangeDecoder, getTimelockedAccountChangeDiscriminatorBytes, getTimelockedAccountChangeEncoder, getTimestampCodec, getTimestampDecoder, getTimestampEncoder, getTokenVaultAddress, getTokenVaultCodec, getTokenVaultDecoder, getTokenVaultDiscriminatorBytes, getTokenVaultEncoder, getUnstakeEarlyDiscriminatorBytes, getUnstakeEarlyInstruction, getUnstakeEarlyInstructionAsync, getUnstakeEarlyInstructionDataCodec, getUnstakeEarlyInstructionDataDecoder, getUnstakeEarlyInstructionDataEncoder, getUnstakeInitiatedEventCodec, getUnstakeInitiatedEventDecoder, getUnstakeInitiatedEventEncoder, getUnstakedEventCodec, getUnstakedEventDecoder, getUnstakedEventEncoder, getUpdateCentralStateDiscriminatorBytes, getUpdateCentralStateInstruction, getUpdateCentralStateInstructionAsync, getUpdateCentralStateInstructionDataCodec, getUpdateCentralStateInstructionDataDecoder, getUpdateCentralStateInstructionDataEncoder, getUtilityPubkeysCodec, getUtilityPubkeysDecoder, getUtilityPubkeysEncoder, getWinningOptionCodec, getWinningOptionDecoder, getWinningOptionEncoder, getWinningOptionsSelectedEventCodec, getWinningOptionsSelectedEventDecoder, getWinningOptionsSelectedEventEncoder, getWithdrawRewardDiscriminatorBytes, getWithdrawRewardInstruction, getWithdrawRewardInstructionAsync, getWithdrawRewardInstructionDataCodec, getWithdrawRewardInstructionDataDecoder, getWithdrawRewardInstructionDataEncoder, identifyOpportunityMarketAccount, identifyOpportunityMarketInstruction, incrementOptionTally, initStakeAccount, initTokenVault, isCircuitSource, isOpportunityMarketError, nonceToBytes, openMarket, parseAddMarketOptionInstruction, parseAddRewardInstruction, parseCancelFeeClaimerChangeInstruction, parseCancelUpdateAuthorityChangeInstruction, parseClaimFeesInstruction, parseCloseStakeAccountInstruction, parseCloseStuckStakeAccountInstruction, parseCreateMarketInstruction, parseDoUnstakeEarlyInstruction, parseEndRevealPeriodInstruction, parseFinalizeNewFeeClaimerInstruction, parseFinalizeNewUpdateAuthorityInstruction, parseIncrementOptionTallyInstruction, parseInitCentralStateInstruction, parseInitStakeAccountInstruction, parseInitTokenVaultInstruction, parseOpenMarketInstruction, parsePauseMarketInstruction, parseProposeNewFeeClaimerInstruction, parseProposeNewUpdateAuthorityInstruction, parseReclaimStakeInstruction, parseResumeMarketInstruction, parseRevealStakeCallbackInstruction, parseRevealStakeCompDefInstruction, parseRevealStakeInstruction, parseSelectWinningOptionsInstruction, parseStakeCallbackInstruction, parseStakeCompDefInstruction, parseStakeInstruction, parseUnstakeEarlyInstruction, parseUpdateCentralStateInstruction, parseWithdrawRewardInstruction, pauseMarket, proposeNewFeeClaimer, proposeNewUpdateAuthority, randomComputationOffset, randomStateNonce, reclaimStake, resumeMarket, revealStake, selectWinningOptions, stake, toNumberArray, unstakeEarly, withdrawReward };
+export { ADD_MARKET_OPTION_DISCRIMINATOR, ADD_REWARD_DISCRIMINATOR, ALLOWED_MINT_DISCRIMINATOR, ALLOWED_MINT_SEED, ALL_COMP_DEF_CIRCUITS, ARCIUM_SIGNER_ACCOUNT_DISCRIMINATOR, type Activation, type ActivationArgs, type AddMarketOptionAsyncInput, type AddMarketOptionInput, type AddMarketOptionInstruction, type AddMarketOptionInstructionData, type AddMarketOptionInstructionDataArgs, type AddMarketOptionParams, type AddRewardAsyncInput, type AddRewardInput, type AddRewardInstruction, type AddRewardInstructionData, type AddRewardInstructionDataArgs, type AddRewardParams, type AllowedMint, type AllowedMintArgs, type AllowedMintInitializedEvent, type AllowedMintInitializedEventArgs, type ArciumSignerAccount, type ArciumSignerAccountArgs, type AwaitComputationOptions, type BN254G2BLSPublicKey, type BN254G2BLSPublicKeyArgs, type BaseInstructionParams, type ByteArray, CLAIM_CREATOR_FEES_DISCRIMINATOR, CLAIM_FEES_DISCRIMINATOR, CLOSE_OPTION_ACCOUNT_DISCRIMINATOR, CLOSE_STAKE_ACCOUNT_DISCRIMINATOR, CLOSE_STUCK_STAKE_ACCOUNT_DISCRIMINATOR, CREATE_MARKET_DISCRIMINATOR, type CircuitSource, type CircuitSourceArgs, type ClaimCreatorFeesAsyncInput, type ClaimCreatorFeesInput, type ClaimCreatorFeesInstruction, type ClaimCreatorFeesInstructionData, type ClaimCreatorFeesInstructionDataArgs, type ClaimCreatorFeesParams, type ClaimFeesAsyncInput, type ClaimFeesInput, type ClaimFeesInstruction, type ClaimFeesInstructionData, type ClaimFeesInstructionDataArgs, type ClaimFeesParams, type ClockAccount, type ClockAccountArgs, type CloseOptionAccountAsyncInput, type CloseOptionAccountInput, type CloseOptionAccountInstruction, type CloseOptionAccountInstructionData, type CloseOptionAccountInstructionDataArgs, type CloseOptionAccountParams, type CloseStakeAccountAsyncInput, type CloseStakeAccountInput, type CloseStakeAccountInstruction, type CloseStakeAccountInstructionData, type CloseStakeAccountInstructionDataArgs, type CloseStakeAccountParams, type CloseStuckStakeAccountAsyncInput, type CloseStuckStakeAccountInput, type CloseStuckStakeAccountInstruction, type CloseStuckStakeAccountInstructionData, type CloseStuckStakeAccountInstructionDataArgs, type CloseStuckStakeAccountParams, type Cluster, type ClusterArgs, type CollectedFees, type CollectedFeesArgs, type CompDefCircuitName, type ComputationDefinitionAccount, type ComputationDefinitionAccountArgs, type ComputationDefinitionMeta, type ComputationDefinitionMetaArgs, type ComputationResult, type ComputationSignature, type ComputationSignatureArgs, type CreateMarketAsyncInput, type CreateMarketInput, type CreateMarketInstruction, type CreateMarketInstructionData, type CreateMarketInstructionDataArgs, type CreateMarketParams, type CreatePlatformConfigParams, type CreatorFeesClaimedEvent, type CreatorFeesClaimedEventArgs, END_REVEAL_PERIOD_DISCRIMINATOR, type EndRevealPeriodInput, type EndRevealPeriodInstruction, type EndRevealPeriodInstructionData, type EndRevealPeriodInstructionDataArgs, type EndRevealPeriodParams, type Epoch, type EpochArgs, FINALIZE_REVEAL_STAKE_DISCRIMINATOR, type FeeClaimAuthorityChangedEvent, type FeeClaimAuthorityChangedEventArgs, type FeePool, type FeePoolArgs, type FeeRates, type FeeRatesArgs, type FeesClaimedEvent, type FeesClaimedEventArgs, type FinalizeRevealStakeAsyncInput, type FinalizeRevealStakeInput, type FinalizeRevealStakeInstruction, type FinalizeRevealStakeInstructionData, type FinalizeRevealStakeInstructionDataArgs, type FinalizeRevealStakeParams, INIT_ALLOWED_MINT_DISCRIMINATOR, INIT_PLATFORM_CONFIG_DISCRIMINATOR, INIT_STAKE_ACCOUNT_DISCRIMINATOR, type InitAllowedMintAsyncInput, type InitAllowedMintInput, type InitAllowedMintInstruction, type InitAllowedMintInstructionData, type InitAllowedMintInstructionDataArgs, type InitAllowedMintParams, type InitCompDefConfig, type InitPlatformConfigAsyncInput, type InitPlatformConfigInput, type InitPlatformConfigInstruction, type InitPlatformConfigInstructionData, type InitPlatformConfigInstructionDataArgs, type InitStakeAccountAsyncInput, type InitStakeAccountInput, type InitStakeAccountInstruction, type InitStakeAccountInstructionData, type InitStakeAccountInstructionDataArgs, type InitStakeAccountParams, LocalCircuitSource, type LocalCircuitSourceArgs, type MXEAccount, type MXEAccountArgs, type MarketCreatedEvent, type MarketCreatedEventArgs, type MarketOpenedEvent, type MarketOpenedEventArgs, type MarketOptionCreatedEvent, type MarketOptionCreatedEventArgs, type MarketResolvedEvent, type MarketResolvedEventArgs, MxeStatus, type MxeStatusArgs, type NodeMetadata, type NodeMetadataArgs, type NodeRef, type NodeRefArgs, OPEN_MARKET_DISCRIMINATOR, OPPORTUNITY_MARKET_DISCRIMINATOR, OPPORTUNITY_MARKET_ERROR__ABORTED_COMPUTATION, OPPORTUNITY_MARKET_ERROR__ADD_OPTION_STAKE_FAILED, OPPORTUNITY_MARKET_ERROR__ALREADY_REVEALED, OPPORTUNITY_MARKET_ERROR__ALREADY_STAKED, OPPORTUNITY_MARKET_ERROR__ALREADY_UNSTAKED, OPPORTUNITY_MARKET_ERROR__CREATOR_MISMATCH, OPPORTUNITY_MARKET_ERROR__DEPOSIT_BELOW_MINIMUM, OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_BALANCE, OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_REWARD_FUNDING, OPPORTUNITY_MARKET_ERROR__INVALID_ACCOUNT_STATE, OPPORTUNITY_MARKET_ERROR__INVALID_FEE_RATES, OPPORTUNITY_MARKET_ERROR__INVALID_MINT, OPPORTUNITY_MARKET_ERROR__INVALID_OPTION_ID, OPPORTUNITY_MARKET_ERROR__INVALID_PARAMETERS, OPPORTUNITY_MARKET_ERROR__LOCKED, OPPORTUNITY_MARKET_ERROR__MARKET_ALREADY_OPEN, OPPORTUNITY_MARKET_ERROR__MARKET_NOT_OPEN, OPPORTUNITY_MARKET_ERROR__MARKET_NOT_PAUSED, OPPORTUNITY_MARKET_ERROR__MARKET_NOT_RESOLVED, OPPORTUNITY_MARKET_ERROR__MARKET_PAUSED, OPPORTUNITY_MARKET_ERROR__NOT_REVEALED, OPPORTUNITY_MARKET_ERROR__NO_FEES_TO_CLAIM, OPPORTUNITY_MARKET_ERROR__NO_REWARD_TO_CLAIM, OPPORTUNITY_MARKET_ERROR__NO_STAKE, OPPORTUNITY_MARKET_ERROR__OPTION_STILL_NEEDED, OPPORTUNITY_MARKET_ERROR__OVERFLOW, OPPORTUNITY_MARKET_ERROR__REVEAL_PERIOD_ENDED, OPPORTUNITY_MARKET_ERROR__REVEAL_PERIOD_NOT_OVER, OPPORTUNITY_MARKET_ERROR__REWARD_ALREADY_CLAIMED, OPPORTUNITY_MARKET_ERROR__SELECT_OPTIONS_DEADLINE_PASSED, OPPORTUNITY_MARKET_ERROR__STAKE_BELOW_MINIMUM, OPPORTUNITY_MARKET_ERROR__STAKE_NOT_STUCK, OPPORTUNITY_MARKET_ERROR__TALLY_ALREADY_INCREMENTED, OPPORTUNITY_MARKET_ERROR__TIME_WINDOW_MISMATCH, OPPORTUNITY_MARKET_ERROR__UNAUTHORIZED, OPPORTUNITY_MARKET_ERROR__WINNER_ALREADY_SELECTED, OPPORTUNITY_MARKET_OPTION_DISCRIMINATOR, OPPORTUNITY_MARKET_OPTION_SEED, OPPORTUNITY_MARKET_PROGRAM_ADDRESS, OPPORTUNITY_MARKET_SEED, OPPORTUNITY_MARKET_SPONSOR_DISCRIMINATOR, type OffChainCircuitSource, type OffChainCircuitSourceArgs, type OnChainCircuitSource, type OnChainCircuitSourceArgs, type OpenMarketInput, type OpenMarketInstruction, type OpenMarketInstructionData, type OpenMarketInstructionDataArgs, type OpenMarketParams, type OpportunityMarket, OpportunityMarketAccount, type OpportunityMarketArgs, type OpportunityMarketError, OpportunityMarketInstruction, type OpportunityMarketOption, type OpportunityMarketOptionArgs, type OpportunityMarketSponsor, type OpportunityMarketSponsorArgs, type OptionClosedEvent, type OptionClosedEventArgs, Output, type OutputArgs, PAUSE_STAKING_DISCRIMINATOR, PLATFORM_CONFIG_DISCRIMINATOR, PLATFORM_CONFIG_SEED, Parameter, type ParameterArgs, type ParsedAddMarketOptionInstruction, type ParsedAddRewardInstruction, type ParsedClaimCreatorFeesInstruction, type ParsedClaimFeesInstruction, type ParsedCloseOptionAccountInstruction, type ParsedCloseStakeAccountInstruction, type ParsedCloseStuckStakeAccountInstruction, type ParsedCreateMarketInstruction, type ParsedEndRevealPeriodInstruction, type ParsedFinalizeRevealStakeInstruction, type ParsedInitAllowedMintInstruction, type ParsedInitPlatformConfigInstruction, type ParsedInitStakeAccountInstruction, type ParsedOpenMarketInstruction, type ParsedOpportunityMarketInstruction, type ParsedPauseStakingInstruction, type ParsedResolveMarketInstruction, type ParsedResumeStakingInstruction, type ParsedRevealStakeCallbackInstruction, type ParsedRevealStakeCompDefInstruction, type ParsedRevealStakeInstruction, type ParsedSetFeeClaimAuthorityInstruction, type ParsedSetUpdateAuthorityInstruction, type ParsedSetWinningOptionInstruction, type ParsedStakeCallbackInstruction, type ParsedStakeCompDefInstruction, type ParsedStakeInstruction, type ParsedUnstakeInstruction, type ParsedUpdatePlatformConfigInstruction, type ParsedWithdrawRewardInstruction, type PauseStakingInput, type PauseStakingInstruction, type PauseStakingInstructionData, type PauseStakingInstructionDataArgs, type PauseStakingParams, type PlatformConfig, type PlatformConfigArgs, RESOLVE_MARKET_DISCRIMINATOR, RESUME_STAKING_DISCRIMINATOR, REVEAL_STAKE_CALLBACK_DISCRIMINATOR, REVEAL_STAKE_COMP_DEF_DISCRIMINATOR, REVEAL_STAKE_DISCRIMINATOR, type ResolveMarketInput, type ResolveMarketInstruction, type ResolveMarketInstructionData, type ResolveMarketInstructionDataArgs, type ResolveMarketParams, type ResumeStakingInput, type ResumeStakingInstruction, type ResumeStakingInstructionData, type ResumeStakingInstructionDataArgs, type ResumeStakingParams, type RevealPeriodEndedEvent, type RevealPeriodEndedEventArgs, type RevealStakeAsyncInput, type RevealStakeCallbackInput, type RevealStakeCallbackInstruction, type RevealStakeCallbackInstructionData, type RevealStakeCallbackInstructionDataArgs, type RevealStakeCompDefInput, type RevealStakeCompDefInstruction, type RevealStakeCompDefInstructionData, type RevealStakeCompDefInstructionDataArgs, type RevealStakeFinalizedEvent, type RevealStakeFinalizedEventArgs, type RevealStakeInput, type RevealStakeInstruction, type RevealStakeInstructionData, type RevealStakeInstructionDataArgs, type RevealStakeOutput, type RevealStakeOutputArgs, type RevealStakeParams, type RewardAddedEvent, type RewardAddedEventArgs, type RewardClaimedEvent, type RewardClaimedEventArgs, type RewardWithdrawnEvent, type RewardWithdrawnEventArgs, 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, type SetFeeClaimAuthorityInput, type SetFeeClaimAuthorityInstruction, type SetFeeClaimAuthorityInstructionData, type SetFeeClaimAuthorityInstructionDataArgs, type SetFeeClaimAuthorityParams, type SetUpdateAuthorityInput, type SetUpdateAuthorityInstruction, type SetUpdateAuthorityInstructionData, type SetUpdateAuthorityInstructionDataArgs, type SetUpdateAuthorityParams, type SetWinningOptionAsyncInput, type SetWinningOptionInput, type SetWinningOptionInstruction, type SetWinningOptionInstructionData, type SetWinningOptionInstructionDataArgs, type SetWinningOptionParams, type StakeAccount, type StakeAccountArgs, type StakeAccountInitializedEvent, type StakeAccountInitializedEventArgs, type StakeAsyncInput, type StakeCallbackInput, type StakeCallbackInstruction, type StakeCallbackInstructionData, type StakeCallbackInstructionDataArgs, type StakeCompDefInput, type StakeCompDefInstruction, type StakeCompDefInstructionData, type StakeCompDefInstructionDataArgs, type StakeInput, type StakeInstruction, type StakeInstructionData, type StakeInstructionDataArgs, type StakeOutput, type StakeOutputArgs, type StakeOutputStruct0, type StakeOutputStruct0Args, type StakeParams, type StakeRevealedEvent, type StakeRevealedEventArgs, type StakedEvent, type StakedEventArgs, type StakingPausedEvent, type StakingPausedEventArgs, type StakingResumedEvent, type StakingResumedEventArgs, type StuckStakeClosedEvent, type StuckStakeClosedEventArgs, type Timestamp, type TimestampArgs, UNSTAKE_DISCRIMINATOR, UPDATE_PLATFORM_CONFIG_DISCRIMINATOR, type UnstakeAsyncInput, type UnstakeInput, type UnstakeInstruction, type UnstakeInstructionData, type UnstakeInstructionDataArgs, type UnstakeParams, type UnstakedEvent, type UnstakedEventArgs, type UpdateAuthorityChangedEvent, type UpdateAuthorityChangedEventArgs, type UpdatePlatformConfigInput, type UpdatePlatformConfigInstruction, type UpdatePlatformConfigInstructionData, type UpdatePlatformConfigInstructionDataArgs, type UpdatePlatformConfigParams, type UtilityPubkeys, type UtilityPubkeysArgs, WITHDRAW_REWARD_DISCRIMINATOR, type WinningOptionSetEvent, type WinningOptionSetEventArgs, type WithdrawRewardAsyncInput, type WithdrawRewardInput, type WithdrawRewardInstruction, type WithdrawRewardInstructionData, type WithdrawRewardInstructionDataArgs, type WithdrawRewardParams, type X25519Keypair, addMarketOption, addReward, awaitBatchComputationFinalization, awaitComputationFinalization, circuitSource, claimCreatorFees, claimFees, closeOptionAccount, closeStakeAccount, closeStuckStakeAccount, createCipher, createMarket, createPlatformConfig, decodeAllowedMint, decodeArciumSignerAccount, decodeOpportunityMarket, decodeOpportunityMarketOption, decodeOpportunityMarketSponsor, decodePlatformConfig, decodeStakeAccount, deriveSharedSecret, deriveX25519KeypairFromSignature, endRevealPeriod, fetchAllAllowedMint, fetchAllArciumSignerAccount, fetchAllMaybeAllowedMint, fetchAllMaybeArciumSignerAccount, fetchAllMaybeOpportunityMarket, fetchAllMaybeOpportunityMarketOption, fetchAllMaybeOpportunityMarketSponsor, fetchAllMaybePlatformConfig, fetchAllMaybeStakeAccount, fetchAllOpportunityMarket, fetchAllOpportunityMarketOption, fetchAllOpportunityMarketSponsor, fetchAllPlatformConfig, fetchAllStakeAccount, fetchAllowedMint, fetchArciumSignerAccount, fetchMaybeAllowedMint, fetchMaybeArciumSignerAccount, fetchMaybeOpportunityMarket, fetchMaybeOpportunityMarketOption, fetchMaybeOpportunityMarketSponsor, fetchMaybePlatformConfig, fetchMaybeStakeAccount, fetchOpportunityMarket, fetchOpportunityMarketOption, fetchOpportunityMarketSponsor, fetchPlatformConfig, fetchStakeAccount, finalizeRevealStake, generateX25519Keypair, getActivationCodec, getActivationDecoder, getActivationEncoder, getAddMarketOptionDiscriminatorBytes, getAddMarketOptionInstruction, getAddMarketOptionInstructionAsync, getAddMarketOptionInstructionDataCodec, getAddMarketOptionInstructionDataDecoder, getAddMarketOptionInstructionDataEncoder, getAddRewardDiscriminatorBytes, getAddRewardInstruction, getAddRewardInstructionAsync, getAddRewardInstructionDataCodec, getAddRewardInstructionDataDecoder, getAddRewardInstructionDataEncoder, getAllowedMintAddress, getAllowedMintCodec, getAllowedMintDecoder, getAllowedMintDiscriminatorBytes, getAllowedMintEncoder, getAllowedMintInitializedEventCodec, getAllowedMintInitializedEventDecoder, getAllowedMintInitializedEventEncoder, getArciumSignerAccountCodec, getArciumSignerAccountDecoder, getArciumSignerAccountDiscriminatorBytes, getArciumSignerAccountEncoder, getBN254G2BLSPublicKeyCodec, getBN254G2BLSPublicKeyDecoder, getBN254G2BLSPublicKeyEncoder, getCircuitSourceCodec, getCircuitSourceDecoder, getCircuitSourceEncoder, getClaimCreatorFeesDiscriminatorBytes, getClaimCreatorFeesInstruction, getClaimCreatorFeesInstructionAsync, getClaimCreatorFeesInstructionDataCodec, getClaimCreatorFeesInstructionDataDecoder, getClaimCreatorFeesInstructionDataEncoder, getClaimFeesDiscriminatorBytes, getClaimFeesInstruction, getClaimFeesInstructionAsync, getClaimFeesInstructionDataCodec, getClaimFeesInstructionDataDecoder, getClaimFeesInstructionDataEncoder, getClockAccountCodec, getClockAccountDecoder, getClockAccountEncoder, getCloseOptionAccountDiscriminatorBytes, getCloseOptionAccountInstruction, getCloseOptionAccountInstructionAsync, getCloseOptionAccountInstructionDataCodec, getCloseOptionAccountInstructionDataDecoder, getCloseOptionAccountInstructionDataEncoder, getCloseStakeAccountDiscriminatorBytes, getCloseStakeAccountInstruction, getCloseStakeAccountInstructionAsync, getCloseStakeAccountInstructionDataCodec, getCloseStakeAccountInstructionDataDecoder, getCloseStakeAccountInstructionDataEncoder, getCloseStuckStakeAccountDiscriminatorBytes, getCloseStuckStakeAccountInstruction, getCloseStuckStakeAccountInstructionAsync, getCloseStuckStakeAccountInstructionDataCodec, getCloseStuckStakeAccountInstructionDataDecoder, getCloseStuckStakeAccountInstructionDataEncoder, getClusterCodec, getClusterDecoder, getClusterEncoder, getCollectedFeesCodec, getCollectedFeesDecoder, getCollectedFeesEncoder, getCompDefAccount, getCompDefOffsetNumber, getComputationDefinitionAccountCodec, getComputationDefinitionAccountDecoder, getComputationDefinitionAccountEncoder, getComputationDefinitionMetaCodec, getComputationDefinitionMetaDecoder, getComputationDefinitionMetaEncoder, getComputationSignatureCodec, getComputationSignatureDecoder, getComputationSignatureEncoder, getCreateMarketDiscriminatorBytes, getCreateMarketInstruction, getCreateMarketInstructionAsync, getCreateMarketInstructionDataCodec, getCreateMarketInstructionDataDecoder, getCreateMarketInstructionDataEncoder, getCreatorFeesClaimedEventCodec, getCreatorFeesClaimedEventDecoder, getCreatorFeesClaimedEventEncoder, getEndRevealPeriodDiscriminatorBytes, getEndRevealPeriodInstruction, getEndRevealPeriodInstructionDataCodec, getEndRevealPeriodInstructionDataDecoder, getEndRevealPeriodInstructionDataEncoder, getEpochCodec, getEpochDecoder, getEpochEncoder, getFeeClaimAuthorityChangedEventCodec, getFeeClaimAuthorityChangedEventDecoder, getFeeClaimAuthorityChangedEventEncoder, getFeePoolCodec, getFeePoolDecoder, getFeePoolEncoder, getFeeRatesCodec, getFeeRatesDecoder, getFeeRatesEncoder, getFeesClaimedEventCodec, getFeesClaimedEventDecoder, getFeesClaimedEventEncoder, getFinalizeRevealStakeDiscriminatorBytes, getFinalizeRevealStakeInstruction, getFinalizeRevealStakeInstructionAsync, getFinalizeRevealStakeInstructionDataCodec, getFinalizeRevealStakeInstructionDataDecoder, getFinalizeRevealStakeInstructionDataEncoder, getInitAllowedMintDiscriminatorBytes, getInitAllowedMintInstruction, getInitAllowedMintInstructionAsync, getInitAllowedMintInstructionDataCodec, getInitAllowedMintInstructionDataDecoder, getInitAllowedMintInstructionDataEncoder, getInitCompDefInstruction, getInitPlatformConfigDiscriminatorBytes, getInitPlatformConfigInstruction, getInitPlatformConfigInstructionAsync, getInitPlatformConfigInstructionDataCodec, getInitPlatformConfigInstructionDataDecoder, getInitPlatformConfigInstructionDataEncoder, getInitStakeAccountDiscriminatorBytes, getInitStakeAccountInstruction, getInitStakeAccountInstructionAsync, getInitStakeAccountInstructionDataCodec, getInitStakeAccountInstructionDataDecoder, getInitStakeAccountInstructionDataEncoder, getLocalCircuitSourceCodec, getLocalCircuitSourceDecoder, getLocalCircuitSourceEncoder, getMXEAccountCodec, getMXEAccountDecoder, getMXEAccountEncoder, getMarketCreatedEventCodec, getMarketCreatedEventDecoder, getMarketCreatedEventEncoder, getMarketOpenedEventCodec, getMarketOpenedEventDecoder, getMarketOpenedEventEncoder, getMarketOptionCreatedEventCodec, getMarketOptionCreatedEventDecoder, getMarketOptionCreatedEventEncoder, getMarketResolvedEventCodec, getMarketResolvedEventDecoder, getMarketResolvedEventEncoder, getMxeAccount, getMxeStatusCodec, getMxeStatusDecoder, getMxeStatusEncoder, getNodeMetadataCodec, getNodeMetadataDecoder, getNodeMetadataEncoder, getNodeRefCodec, getNodeRefDecoder, getNodeRefEncoder, getOffChainCircuitSourceCodec, getOffChainCircuitSourceDecoder, getOffChainCircuitSourceEncoder, getOnChainCircuitSourceCodec, getOnChainCircuitSourceDecoder, getOnChainCircuitSourceEncoder, getOpenMarketDiscriminatorBytes, getOpenMarketInstruction, getOpenMarketInstructionDataCodec, getOpenMarketInstructionDataDecoder, getOpenMarketInstructionDataEncoder, getOpportunityMarketAddress, getOpportunityMarketCodec, getOpportunityMarketDecoder, getOpportunityMarketDiscriminatorBytes, getOpportunityMarketEncoder, getOpportunityMarketErrorMessage, getOpportunityMarketOptionAddress, getOpportunityMarketOptionCodec, getOpportunityMarketOptionDecoder, getOpportunityMarketOptionDiscriminatorBytes, getOpportunityMarketOptionEncoder, getOpportunityMarketSponsorAddress, getOpportunityMarketSponsorCodec, getOpportunityMarketSponsorDecoder, getOpportunityMarketSponsorDiscriminatorBytes, getOpportunityMarketSponsorEncoder, getOptionClosedEventCodec, getOptionClosedEventDecoder, getOptionClosedEventEncoder, getOutputCodec, getOutputDecoder, getOutputEncoder, getParameterCodec, getParameterDecoder, getParameterEncoder, getPauseStakingDiscriminatorBytes, getPauseStakingInstruction, getPauseStakingInstructionDataCodec, getPauseStakingInstructionDataDecoder, getPauseStakingInstructionDataEncoder, getPlatformConfigAddress, getPlatformConfigCodec, getPlatformConfigDecoder, getPlatformConfigDiscriminatorBytes, getPlatformConfigEncoder, getResolveMarketDiscriminatorBytes, getResolveMarketInstruction, getResolveMarketInstructionDataCodec, getResolveMarketInstructionDataDecoder, getResolveMarketInstructionDataEncoder, getResumeStakingDiscriminatorBytes, getResumeStakingInstruction, getResumeStakingInstructionDataCodec, getResumeStakingInstructionDataDecoder, getResumeStakingInstructionDataEncoder, 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, getRewardAddedEventCodec, getRewardAddedEventDecoder, getRewardAddedEventEncoder, getRewardClaimedEventCodec, getRewardClaimedEventDecoder, getRewardClaimedEventEncoder, getRewardWithdrawnEventCodec, getRewardWithdrawnEventDecoder, getRewardWithdrawnEventEncoder, getSetFeeClaimAuthorityDiscriminatorBytes, getSetFeeClaimAuthorityInstruction, getSetFeeClaimAuthorityInstructionDataCodec, getSetFeeClaimAuthorityInstructionDataDecoder, getSetFeeClaimAuthorityInstructionDataEncoder, getSetUpdateAuthorityDiscriminatorBytes, getSetUpdateAuthorityInstruction, getSetUpdateAuthorityInstructionDataCodec, getSetUpdateAuthorityInstructionDataDecoder, getSetUpdateAuthorityInstructionDataEncoder, getSetWinningOptionDiscriminatorBytes, getSetWinningOptionInstruction, getSetWinningOptionInstructionAsync, getSetWinningOptionInstructionDataCodec, getSetWinningOptionInstructionDataDecoder, getSetWinningOptionInstructionDataEncoder, getStakeAccountAddress, 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, getStakeRevealedEventCodec, getStakeRevealedEventDecoder, getStakeRevealedEventEncoder, getStakedEventCodec, getStakedEventDecoder, getStakedEventEncoder, getStakingPausedEventCodec, getStakingPausedEventDecoder, getStakingPausedEventEncoder, getStakingResumedEventCodec, getStakingResumedEventDecoder, getStakingResumedEventEncoder, getStuckStakeClosedEventCodec, getStuckStakeClosedEventDecoder, getStuckStakeClosedEventEncoder, getTimestampCodec, getTimestampDecoder, getTimestampEncoder, getUnstakeDiscriminatorBytes, getUnstakeInstruction, getUnstakeInstructionAsync, getUnstakeInstructionDataCodec, getUnstakeInstructionDataDecoder, getUnstakeInstructionDataEncoder, getUnstakedEventCodec, getUnstakedEventDecoder, getUnstakedEventEncoder, getUpdateAuthorityChangedEventCodec, getUpdateAuthorityChangedEventDecoder, getUpdateAuthorityChangedEventEncoder, getUpdatePlatformConfigDiscriminatorBytes, getUpdatePlatformConfigInstruction, getUpdatePlatformConfigInstructionDataCodec, getUpdatePlatformConfigInstructionDataDecoder, getUpdatePlatformConfigInstructionDataEncoder, getUtilityPubkeysCodec, getUtilityPubkeysDecoder, getUtilityPubkeysEncoder, getWinningOptionSetEventCodec, getWinningOptionSetEventDecoder, getWinningOptionSetEventEncoder, getWithdrawRewardDiscriminatorBytes, getWithdrawRewardInstruction, getWithdrawRewardInstructionAsync, getWithdrawRewardInstructionDataCodec, getWithdrawRewardInstructionDataDecoder, getWithdrawRewardInstructionDataEncoder, identifyOpportunityMarketAccount, identifyOpportunityMarketInstruction, initAllowedMint, initStakeAccount, isCircuitSource, isOpportunityMarketError, nonceToBytes, openMarket, parseAddMarketOptionInstruction, parseAddRewardInstruction, parseClaimCreatorFeesInstruction, parseClaimFeesInstruction, parseCloseOptionAccountInstruction, parseCloseStakeAccountInstruction, parseCloseStuckStakeAccountInstruction, parseCreateMarketInstruction, parseEndRevealPeriodInstruction, parseFinalizeRevealStakeInstruction, parseInitAllowedMintInstruction, parseInitPlatformConfigInstruction, parseInitStakeAccountInstruction, parseOpenMarketInstruction, parsePauseStakingInstruction, parseResolveMarketInstruction, parseResumeStakingInstruction, parseRevealStakeCallbackInstruction, parseRevealStakeCompDefInstruction, parseRevealStakeInstruction, parseSetFeeClaimAuthorityInstruction, parseSetUpdateAuthorityInstruction, parseSetWinningOptionInstruction, parseStakeCallbackInstruction, parseStakeCompDefInstruction, parseStakeInstruction, parseUnstakeInstruction, parseUpdatePlatformConfigInstruction, parseWithdrawRewardInstruction, pauseStaking, randomComputationOffset, randomStateNonce, resolveMarket, resumeStaking, revealStake, setFeeClaimAuthority, setUpdateAuthority, setWinningOption, stake, toNumberArray, unstake, updatePlatformConfig, withdrawReward };