@bench.games/opportunity-markets 0.2.12 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. package/dist/browser/index.js +4104 -4072
  2. package/dist/index.cjs +3531 -3516
  3. package/dist/index.cjs.map +1 -1
  4. package/dist/index.d.cts +1492 -1227
  5. package/dist/index.d.ts +1492 -1227
  6. package/dist/index.js +4104 -4072
  7. package/dist/index.js.map +1 -1
  8. package/package.json +3 -3
package/dist/index.d.ts CHANGED
@@ -1,7 +1,37 @@
1
- import { ReadonlyUint8Array, EncodedAccount, Account, MaybeEncodedAccount, MaybeAccount, fetchEncodedAccounts, Address, 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';
2
- import * as _solana_accounts from '@solana/accounts';
1
+ 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';
3
2
  import { RescueCipher } from '@arcium-hq/client';
4
3
 
4
+ /**
5
+ * This code was AUTOGENERATED using the Codama library.
6
+ * Please DO NOT EDIT THIS FILE, instead use visitors
7
+ * to add features, then rerun Codama to update it.
8
+ *
9
+ * @see https://github.com/codama-idl/codama
10
+ */
11
+
12
+ declare const ALLOWED_MINT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
13
+ declare function getAllowedMintDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
14
+ type AllowedMint = {
15
+ discriminator: ReadonlyUint8Array;
16
+ bump: number;
17
+ platform: Address;
18
+ mint: Address;
19
+ };
20
+ type AllowedMintArgs = {
21
+ bump: number;
22
+ platform: Address;
23
+ mint: Address;
24
+ };
25
+ declare function getAllowedMintEncoder(): FixedSizeEncoder<AllowedMintArgs>;
26
+ declare function getAllowedMintDecoder(): FixedSizeDecoder<AllowedMint>;
27
+ declare function getAllowedMintCodec(): FixedSizeCodec<AllowedMintArgs, AllowedMint>;
28
+ declare function decodeAllowedMint<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<AllowedMint, TAddress>;
29
+ declare function decodeAllowedMint<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<AllowedMint, TAddress>;
30
+ declare function fetchAllowedMint<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<AllowedMint, TAddress>>;
31
+ declare function fetchMaybeAllowedMint<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<AllowedMint, TAddress>>;
32
+ declare function fetchAllAllowedMint(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<AllowedMint>[]>;
33
+ declare function fetchAllMaybeAllowedMint(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<AllowedMint>[]>;
34
+
5
35
  /**
6
36
  * This code was AUTOGENERATED using the Codama library.
7
37
  * Please DO NOT EDIT THIS FILE, instead use visitors
@@ -37,34 +67,17 @@ declare function fetchAllMaybeArciumSignerAccount(rpc: Parameters<typeof fetchEn
37
67
  * @see https://github.com/codama-idl/codama
38
68
  */
39
69
 
40
- declare const CENTRAL_STATE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
41
- declare function getCentralStateDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
42
- type CentralState = {
43
- discriminator: ReadonlyUint8Array;
44
- bump: number;
45
- authority: Address;
46
- protocolFeeBp: number;
47
- feeRecipient: Address;
48
- /** Reserved for future use */
49
- reserved: Array<number>;
70
+ type Activation = {
71
+ activationEpoch: Epoch;
72
+ deactivationEpoch: Epoch;
50
73
  };
51
- type CentralStateArgs = {
52
- bump: number;
53
- authority: Address;
54
- protocolFeeBp: number;
55
- feeRecipient: Address;
56
- /** Reserved for future use */
57
- reserved: Array<number>;
74
+ type ActivationArgs = {
75
+ activationEpoch: EpochArgs;
76
+ deactivationEpoch: EpochArgs;
58
77
  };
59
- declare function getCentralStateEncoder(): FixedSizeEncoder<CentralStateArgs>;
60
- declare function getCentralStateDecoder(): FixedSizeDecoder<CentralState>;
61
- declare function getCentralStateCodec(): FixedSizeCodec<CentralStateArgs, CentralState>;
62
- declare function decodeCentralState<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<CentralState, TAddress>;
63
- declare function decodeCentralState<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<CentralState, TAddress>;
64
- declare function fetchCentralState<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<CentralState, TAddress>>;
65
- declare function fetchMaybeCentralState<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<CentralState, TAddress>>;
66
- declare function fetchAllCentralState(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<CentralState>[]>;
67
- declare function fetchAllMaybeCentralState(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<CentralState>[]>;
78
+ declare function getActivationEncoder(): FixedSizeEncoder<ActivationArgs>;
79
+ declare function getActivationDecoder(): FixedSizeDecoder<Activation>;
80
+ declare function getActivationCodec(): FixedSizeCodec<ActivationArgs, Activation>;
68
81
 
69
82
  /**
70
83
  * This code was AUTOGENERATED using the Codama library.
@@ -74,17 +87,21 @@ declare function fetchAllMaybeCentralState(rpc: Parameters<typeof fetchEncodedAc
74
87
  * @see https://github.com/codama-idl/codama
75
88
  */
76
89
 
77
- type Activation = {
78
- activationEpoch: Epoch;
79
- deactivationEpoch: Epoch;
90
+ type AllowedMintInitializedEvent = {
91
+ allowedMint: Address;
92
+ platform: Address;
93
+ mint: Address;
94
+ timestamp: bigint;
80
95
  };
81
- type ActivationArgs = {
82
- activationEpoch: EpochArgs;
83
- deactivationEpoch: EpochArgs;
96
+ type AllowedMintInitializedEventArgs = {
97
+ allowedMint: Address;
98
+ platform: Address;
99
+ mint: Address;
100
+ timestamp: number | bigint;
84
101
  };
85
- declare function getActivationEncoder(): FixedSizeEncoder<ActivationArgs>;
86
- declare function getActivationDecoder(): FixedSizeDecoder<Activation>;
87
- declare function getActivationCodec(): FixedSizeCodec<ActivationArgs, Activation>;
102
+ declare function getAllowedMintInitializedEventEncoder(): FixedSizeEncoder<AllowedMintInitializedEventArgs>;
103
+ declare function getAllowedMintInitializedEventDecoder(): FixedSizeDecoder<AllowedMintInitializedEvent>;
104
+ declare function getAllowedMintInitializedEventCodec(): FixedSizeCodec<AllowedMintInitializedEventArgs, AllowedMintInitializedEvent>;
88
105
 
89
106
  /**
90
107
  * This code was AUTOGENERATED using the Codama library.
@@ -138,6 +155,134 @@ declare function isCircuitSource<K extends CircuitSource['__kind']>(kind: K, val
138
155
  __kind: K;
139
156
  };
140
157
 
158
+ /**
159
+ * This code was AUTOGENERATED using the Codama library.
160
+ * Please DO NOT EDIT THIS FILE, instead use visitors
161
+ * to add features, then rerun Codama to update it.
162
+ *
163
+ * @see https://github.com/codama-idl/codama
164
+ */
165
+
166
+ /** An account storing the current network epoch */
167
+ type ClockAccount = {
168
+ startEpoch: Epoch;
169
+ currentEpoch: Epoch;
170
+ startEpochTimestamp: Timestamp;
171
+ bump: number;
172
+ };
173
+ type ClockAccountArgs = {
174
+ startEpoch: EpochArgs;
175
+ currentEpoch: EpochArgs;
176
+ startEpochTimestamp: TimestampArgs;
177
+ bump: number;
178
+ };
179
+ declare function getClockAccountEncoder(): FixedSizeEncoder<ClockAccountArgs>;
180
+ declare function getClockAccountDecoder(): FixedSizeDecoder<ClockAccount>;
181
+ declare function getClockAccountCodec(): FixedSizeCodec<ClockAccountArgs, ClockAccount>;
182
+
183
+ /**
184
+ * This code was AUTOGENERATED using the Codama library.
185
+ * Please DO NOT EDIT THIS FILE, instead use visitors
186
+ * to add features, then rerun Codama to update it.
187
+ *
188
+ * @see https://github.com/codama-idl/codama
189
+ */
190
+
191
+ type Cluster = {
192
+ tdInfo: Option<NodeMetadata>;
193
+ authority: Option<Address>;
194
+ clusterSize: number;
195
+ activation: Activation;
196
+ maxCapacity: bigint;
197
+ cuPrice: bigint;
198
+ cuPriceProposals: Array<bigint>;
199
+ lastUpdatedEpoch: Epoch;
200
+ nodes: Array<NodeRef>;
201
+ pendingNodes: Array<number>;
202
+ blsPublicKey: {
203
+ __kind: 'Set';
204
+ fields: readonly [BN254G2BLSPublicKey];
205
+ } | {
206
+ __kind: 'Unset';
207
+ fields: readonly [BN254G2BLSPublicKey, Array<boolean>];
208
+ };
209
+ bump: number;
210
+ };
211
+ type ClusterArgs = {
212
+ tdInfo: OptionOrNullable<NodeMetadataArgs>;
213
+ authority: OptionOrNullable<Address>;
214
+ clusterSize: number;
215
+ activation: ActivationArgs;
216
+ maxCapacity: number | bigint;
217
+ cuPrice: number | bigint;
218
+ cuPriceProposals: Array<number | bigint>;
219
+ lastUpdatedEpoch: EpochArgs;
220
+ nodes: Array<NodeRefArgs>;
221
+ pendingNodes: Array<number>;
222
+ blsPublicKey: {
223
+ __kind: 'Set';
224
+ fields: readonly [BN254G2BLSPublicKeyArgs];
225
+ } | {
226
+ __kind: 'Unset';
227
+ fields: readonly [BN254G2BLSPublicKeyArgs, Array<boolean>];
228
+ };
229
+ bump: number;
230
+ };
231
+ declare function getClusterEncoder(): Encoder<ClusterArgs>;
232
+ declare function getClusterDecoder(): Decoder<Cluster>;
233
+ declare function getClusterCodec(): Codec<ClusterArgs, Cluster>;
234
+
235
+ /**
236
+ * This code was AUTOGENERATED using the Codama library.
237
+ * Please DO NOT EDIT THIS FILE, instead use visitors
238
+ * to add features, then rerun Codama to update it.
239
+ *
240
+ * @see https://github.com/codama-idl/codama
241
+ */
242
+
243
+ type CollectedFees = {
244
+ platformFee: bigint;
245
+ rewardPoolFee: bigint;
246
+ creatorFee: bigint;
247
+ };
248
+ type CollectedFeesArgs = {
249
+ platformFee: number | bigint;
250
+ rewardPoolFee: number | bigint;
251
+ creatorFee: number | bigint;
252
+ };
253
+ declare function getCollectedFeesEncoder(): FixedSizeEncoder<CollectedFeesArgs>;
254
+ declare function getCollectedFeesDecoder(): FixedSizeDecoder<CollectedFees>;
255
+ declare function getCollectedFeesCodec(): FixedSizeCodec<CollectedFeesArgs, CollectedFees>;
256
+
257
+ /**
258
+ * This code was AUTOGENERATED using the Codama library.
259
+ * Please DO NOT EDIT THIS FILE, instead use visitors
260
+ * to add features, then rerun Codama to update it.
261
+ *
262
+ * @see https://github.com/codama-idl/codama
263
+ */
264
+
265
+ /** An account representing a [ComputationDefinition] in a MXE. */
266
+ type ComputationDefinitionAccount = {
267
+ deactivationSlot: Option<bigint>;
268
+ cuAmount: bigint;
269
+ definition: ComputationDefinitionMeta;
270
+ circuitSource: CircuitSource;
271
+ bump: number;
272
+ padding: Array<number>;
273
+ };
274
+ type ComputationDefinitionAccountArgs = {
275
+ deactivationSlot: OptionOrNullable<number | bigint>;
276
+ cuAmount: number | bigint;
277
+ definition: ComputationDefinitionMetaArgs;
278
+ circuitSource: CircuitSourceArgs;
279
+ bump: number;
280
+ padding: Array<number>;
281
+ };
282
+ declare function getComputationDefinitionAccountEncoder(): Encoder<ComputationDefinitionAccountArgs>;
283
+ declare function getComputationDefinitionAccountDecoder(): Decoder<ComputationDefinitionAccount>;
284
+ declare function getComputationDefinitionAccountCodec(): Codec<ComputationDefinitionAccountArgs, ComputationDefinitionAccount>;
285
+
141
286
  /**
142
287
  * This code was AUTOGENERATED using the Codama library.
143
288
  * Please DO NOT EDIT THIS FILE, instead use visitors
@@ -180,6 +325,34 @@ declare function getComputationSignatureEncoder(): Encoder<ComputationSignatureA
180
325
  declare function getComputationSignatureDecoder(): Decoder<ComputationSignature>;
181
326
  declare function getComputationSignatureCodec(): Codec<ComputationSignatureArgs, ComputationSignature>;
182
327
 
328
+ /**
329
+ * This code was AUTOGENERATED using the Codama library.
330
+ * Please DO NOT EDIT THIS FILE, instead use visitors
331
+ * to add features, then rerun Codama to update it.
332
+ *
333
+ * @see https://github.com/codama-idl/codama
334
+ */
335
+
336
+ type CreatorFeesClaimedEvent = {
337
+ market: Address;
338
+ creatorFeeClaimer: Address;
339
+ mint: Address;
340
+ destination: Address;
341
+ amount: bigint;
342
+ timestamp: bigint;
343
+ };
344
+ type CreatorFeesClaimedEventArgs = {
345
+ market: Address;
346
+ creatorFeeClaimer: Address;
347
+ mint: Address;
348
+ destination: Address;
349
+ amount: number | bigint;
350
+ timestamp: number | bigint;
351
+ };
352
+ declare function getCreatorFeesClaimedEventEncoder(): FixedSizeEncoder<CreatorFeesClaimedEventArgs>;
353
+ declare function getCreatorFeesClaimedEventDecoder(): FixedSizeDecoder<CreatorFeesClaimedEvent>;
354
+ declare function getCreatorFeesClaimedEventCodec(): FixedSizeCodec<CreatorFeesClaimedEventArgs, CreatorFeesClaimedEvent>;
355
+
183
356
  /**
184
357
  * This code was AUTOGENERATED using the Codama library.
185
358
  * Please DO NOT EDIT THIS FILE, instead use visitors
@@ -195,6 +368,64 @@ declare function getEpochEncoder(): FixedSizeEncoder<EpochArgs>;
195
368
  declare function getEpochDecoder(): FixedSizeDecoder<Epoch>;
196
369
  declare function getEpochCodec(): FixedSizeCodec<EpochArgs, Epoch>;
197
370
 
371
+ /**
372
+ * This code was AUTOGENERATED using the Codama library.
373
+ * Please DO NOT EDIT THIS FILE, instead use visitors
374
+ * to add features, then rerun Codama to update it.
375
+ *
376
+ * @see https://github.com/codama-idl/codama
377
+ */
378
+
379
+ type FeeClaimAuthorityChangedEvent = {
380
+ platformConfig: Address;
381
+ oldValue: Address;
382
+ newValue: Address;
383
+ timestamp: bigint;
384
+ };
385
+ type FeeClaimAuthorityChangedEventArgs = {
386
+ platformConfig: Address;
387
+ oldValue: Address;
388
+ newValue: Address;
389
+ timestamp: number | bigint;
390
+ };
391
+ declare function getFeeClaimAuthorityChangedEventEncoder(): FixedSizeEncoder<FeeClaimAuthorityChangedEventArgs>;
392
+ declare function getFeeClaimAuthorityChangedEventDecoder(): FixedSizeDecoder<FeeClaimAuthorityChangedEvent>;
393
+ declare function getFeeClaimAuthorityChangedEventCodec(): FixedSizeCodec<FeeClaimAuthorityChangedEventArgs, FeeClaimAuthorityChangedEvent>;
394
+
395
+ /**
396
+ * This code was AUTOGENERATED using the Codama library.
397
+ * Please DO NOT EDIT THIS FILE, instead use visitors
398
+ * to add features, then rerun Codama to update it.
399
+ *
400
+ * @see https://github.com/codama-idl/codama
401
+ */
402
+
403
+ type FeePool = {
404
+ bump: number;
405
+ };
406
+ type FeePoolArgs = FeePool;
407
+ declare function getFeePoolEncoder(): FixedSizeEncoder<FeePoolArgs>;
408
+ declare function getFeePoolDecoder(): FixedSizeDecoder<FeePool>;
409
+ declare function getFeePoolCodec(): FixedSizeCodec<FeePoolArgs, FeePool>;
410
+
411
+ /**
412
+ * This code was AUTOGENERATED using the Codama library.
413
+ * Please DO NOT EDIT THIS FILE, instead use visitors
414
+ * to add features, then rerun Codama to update it.
415
+ *
416
+ * @see https://github.com/codama-idl/codama
417
+ */
418
+
419
+ type FeeRates = {
420
+ platformFeeBp: number;
421
+ rewardPoolFeeBp: number;
422
+ creatorFeeBp: number;
423
+ };
424
+ type FeeRatesArgs = FeeRates;
425
+ declare function getFeeRatesEncoder(): FixedSizeEncoder<FeeRatesArgs>;
426
+ declare function getFeeRatesDecoder(): FixedSizeDecoder<FeeRates>;
427
+ declare function getFeeRatesCodec(): FixedSizeCodec<FeeRatesArgs, FeeRates>;
428
+
198
429
  /**
199
430
  * This code was AUTOGENERATED using the Codama library.
200
431
  * Please DO NOT EDIT THIS FILE, instead use visitors
@@ -204,16 +435,18 @@ declare function getEpochCodec(): FixedSizeCodec<EpochArgs, Epoch>;
204
435
  */
205
436
 
206
437
  type FeesClaimedEvent = {
207
- tokenVault: Address;
438
+ market: Address;
439
+ platform: Address;
208
440
  mint: Address;
209
- feeRecipient: Address;
441
+ destination: Address;
210
442
  amount: bigint;
211
443
  timestamp: bigint;
212
444
  };
213
445
  type FeesClaimedEventArgs = {
214
- tokenVault: Address;
446
+ market: Address;
447
+ platform: Address;
215
448
  mint: Address;
216
- feeRecipient: Address;
449
+ destination: Address;
217
450
  amount: number | bigint;
218
451
  timestamp: number | bigint;
219
452
  };
@@ -250,34 +483,44 @@ declare function getLocalCircuitSourceCodec(): FixedSizeCodec<LocalCircuitSource
250
483
  type MarketCreatedEvent = {
251
484
  market: Address;
252
485
  creator: Address;
486
+ platform: Address;
253
487
  index: bigint;
254
488
  mint: Address;
255
- timeToStake: bigint;
256
- timeToReveal: bigint;
257
489
  earlinessCutoffSeconds: bigint;
258
- marketAuthority: Option<Address>;
490
+ earlinessMultiplier: number;
491
+ marketAuthority: Address;
259
492
  authorizedReaderPubkey: Array<number>;
260
- unstakeDelaySeconds: bigint;
261
- allowClosingEarly: boolean;
493
+ allowUnstakingEarly: boolean;
494
+ minStakeAmount: bigint;
495
+ feeRates: FeeRates;
496
+ creatorFeeClaimer: Address;
497
+ marketResolutionDeadlineSeconds: bigint;
498
+ minRevealPeriodSeconds: bigint;
499
+ maxRevealPeriodSeconds: bigint;
262
500
  timestamp: bigint;
263
501
  };
264
502
  type MarketCreatedEventArgs = {
265
503
  market: Address;
266
504
  creator: Address;
505
+ platform: Address;
267
506
  index: number | bigint;
268
507
  mint: Address;
269
- timeToStake: number | bigint;
270
- timeToReveal: number | bigint;
271
508
  earlinessCutoffSeconds: number | bigint;
272
- marketAuthority: OptionOrNullable<Address>;
509
+ earlinessMultiplier: number;
510
+ marketAuthority: Address;
273
511
  authorizedReaderPubkey: Array<number>;
274
- unstakeDelaySeconds: number | bigint;
275
- allowClosingEarly: boolean;
512
+ allowUnstakingEarly: boolean;
513
+ minStakeAmount: number | bigint;
514
+ feeRates: FeeRatesArgs;
515
+ creatorFeeClaimer: Address;
516
+ marketResolutionDeadlineSeconds: number | bigint;
517
+ minRevealPeriodSeconds: number | bigint;
518
+ maxRevealPeriodSeconds: number | bigint;
276
519
  timestamp: number | bigint;
277
520
  };
278
- declare function getMarketCreatedEventEncoder(): Encoder<MarketCreatedEventArgs>;
279
- declare function getMarketCreatedEventDecoder(): Decoder<MarketCreatedEvent>;
280
- declare function getMarketCreatedEventCodec(): Codec<MarketCreatedEventArgs, MarketCreatedEvent>;
521
+ declare function getMarketCreatedEventEncoder(): FixedSizeEncoder<MarketCreatedEventArgs>;
522
+ declare function getMarketCreatedEventDecoder(): FixedSizeDecoder<MarketCreatedEvent>;
523
+ declare function getMarketCreatedEventCodec(): FixedSizeCodec<MarketCreatedEventArgs, MarketCreatedEvent>;
281
524
 
282
525
  /**
283
526
  * This code was AUTOGENERATED using the Codama library.
@@ -290,13 +533,13 @@ declare function getMarketCreatedEventCodec(): Codec<MarketCreatedEventArgs, Mar
290
533
  type MarketOpenedEvent = {
291
534
  market: Address;
292
535
  creator: Address;
293
- openTimestamp: bigint;
536
+ stakeEndTimestamp: bigint;
294
537
  timestamp: bigint;
295
538
  };
296
539
  type MarketOpenedEventArgs = {
297
540
  market: Address;
298
541
  creator: Address;
299
- openTimestamp: number | bigint;
542
+ stakeEndTimestamp: number | bigint;
300
543
  timestamp: number | bigint;
301
544
  };
302
545
  declare function getMarketOpenedEventEncoder(): FixedSizeEncoder<MarketOpenedEventArgs>;
@@ -314,14 +557,14 @@ declare function getMarketOpenedEventCodec(): FixedSizeCodec<MarketOpenedEventAr
314
557
  type MarketOptionCreatedEvent = {
315
558
  option: Address;
316
559
  market: Address;
317
- creator: Address;
560
+ signer: Address;
318
561
  id: bigint;
319
562
  timestamp: bigint;
320
563
  };
321
564
  type MarketOptionCreatedEventArgs = {
322
565
  option: Address;
323
566
  market: Address;
324
- creator: Address;
567
+ signer: Address;
325
568
  id: number | bigint;
326
569
  timestamp: number | bigint;
327
570
  };
@@ -337,17 +580,19 @@ declare function getMarketOptionCreatedEventCodec(): FixedSizeCodec<MarketOption
337
580
  * @see https://github.com/codama-idl/codama
338
581
  */
339
582
 
340
- type MarketPausedEvent = {
583
+ type MarketResolvedEvent = {
341
584
  market: Address;
585
+ marketAuthority: Address;
342
586
  timestamp: bigint;
343
587
  };
344
- type MarketPausedEventArgs = {
588
+ type MarketResolvedEventArgs = {
345
589
  market: Address;
590
+ marketAuthority: Address;
346
591
  timestamp: number | bigint;
347
592
  };
348
- declare function getMarketPausedEventEncoder(): FixedSizeEncoder<MarketPausedEventArgs>;
349
- declare function getMarketPausedEventDecoder(): FixedSizeDecoder<MarketPausedEvent>;
350
- declare function getMarketPausedEventCodec(): FixedSizeCodec<MarketPausedEventArgs, MarketPausedEvent>;
593
+ declare function getMarketResolvedEventEncoder(): FixedSizeEncoder<MarketResolvedEventArgs>;
594
+ declare function getMarketResolvedEventDecoder(): FixedSizeDecoder<MarketResolvedEvent>;
595
+ declare function getMarketResolvedEventCodec(): FixedSizeCodec<MarketResolvedEventArgs, MarketResolvedEvent>;
351
596
 
352
597
  /**
353
598
  * This code was AUTOGENERATED using the Codama library.
@@ -357,18 +602,49 @@ declare function getMarketPausedEventCodec(): FixedSizeCodec<MarketPausedEventAr
357
602
  * @see https://github.com/codama-idl/codama
358
603
  */
359
604
 
360
- type MarketResumedEvent = {
361
- market: Address;
362
- timestamp: bigint;
605
+ /** A MPC Execution Environment. */
606
+ type MXEAccount = {
607
+ padding: number;
608
+ cluster: number;
609
+ keygenOffset: bigint;
610
+ keyRecoveryInitOffset: bigint;
611
+ mxeProgramId: Address;
612
+ authority: Option<Address>;
613
+ utilityPubkeys: {
614
+ __kind: 'Set';
615
+ fields: readonly [UtilityPubkeys];
616
+ } | {
617
+ __kind: 'Unset';
618
+ fields: readonly [UtilityPubkeys, Array<boolean>];
619
+ };
620
+ lutOffsetSlot: bigint;
621
+ computationDefinitions: Array<number>;
622
+ status: MxeStatus;
623
+ bump: number;
363
624
  };
364
- type MarketResumedEventArgs = {
365
- market: Address;
366
- timestamp: number | bigint;
625
+ type MXEAccountArgs = {
626
+ padding: number;
627
+ cluster: number;
628
+ keygenOffset: number | bigint;
629
+ keyRecoveryInitOffset: number | bigint;
630
+ mxeProgramId: Address;
631
+ authority: OptionOrNullable<Address>;
632
+ utilityPubkeys: {
633
+ __kind: 'Set';
634
+ fields: readonly [UtilityPubkeysArgs];
635
+ } | {
636
+ __kind: 'Unset';
637
+ fields: readonly [UtilityPubkeysArgs, Array<boolean>];
638
+ };
639
+ lutOffsetSlot: number | bigint;
640
+ computationDefinitions: Array<number>;
641
+ status: MxeStatusArgs;
642
+ bump: number;
367
643
  };
368
- declare function getMarketResumedEventEncoder(): FixedSizeEncoder<MarketResumedEventArgs>;
369
- declare function getMarketResumedEventDecoder(): FixedSizeDecoder<MarketResumedEvent>;
370
- declare function getMarketResumedEventCodec(): FixedSizeCodec<MarketResumedEventArgs, MarketResumedEvent>;
371
-
644
+ declare function getMXEAccountEncoder(): Encoder<MXEAccountArgs>;
645
+ declare function getMXEAccountDecoder(): Decoder<MXEAccount>;
646
+ declare function getMXEAccountCodec(): Codec<MXEAccountArgs, MXEAccount>;
647
+
372
648
  /**
373
649
  * This code was AUTOGENERATED using the Codama library.
374
650
  * Please DO NOT EDIT THIS FILE, instead use visitors
@@ -468,6 +744,34 @@ declare function getOnChainCircuitSourceEncoder(): FixedSizeEncoder<OnChainCircu
468
744
  declare function getOnChainCircuitSourceDecoder(): FixedSizeDecoder<OnChainCircuitSource>;
469
745
  declare function getOnChainCircuitSourceCodec(): FixedSizeCodec<OnChainCircuitSourceArgs, OnChainCircuitSource>;
470
746
 
747
+ /**
748
+ * This code was AUTOGENERATED using the Codama library.
749
+ * Please DO NOT EDIT THIS FILE, instead use visitors
750
+ * to add features, then rerun Codama to update it.
751
+ *
752
+ * @see https://github.com/codama-idl/codama
753
+ */
754
+
755
+ type OptionClosedEvent = {
756
+ option: Address;
757
+ optionId: bigint;
758
+ signer: Address;
759
+ creator: Address;
760
+ market: Address;
761
+ timestamp: bigint;
762
+ };
763
+ type OptionClosedEventArgs = {
764
+ option: Address;
765
+ optionId: number | bigint;
766
+ signer: Address;
767
+ creator: Address;
768
+ market: Address;
769
+ timestamp: number | bigint;
770
+ };
771
+ declare function getOptionClosedEventEncoder(): FixedSizeEncoder<OptionClosedEventArgs>;
772
+ declare function getOptionClosedEventDecoder(): FixedSizeDecoder<OptionClosedEvent>;
773
+ declare function getOptionClosedEventCodec(): FixedSizeCodec<OptionClosedEventArgs, OptionClosedEvent>;
774
+
471
775
  /**
472
776
  * This code was AUTOGENERATED using the Codama library.
473
777
  * Please DO NOT EDIT THIS FILE, instead use visitors
@@ -551,18 +855,54 @@ declare function getParameterCodec(): FixedSizeCodec<ParameterArgs, Parameter>;
551
855
 
552
856
  type RevealPeriodEndedEvent = {
553
857
  market: Address;
554
- authority: Address;
858
+ signer: Address;
555
859
  timestamp: bigint;
556
860
  };
557
861
  type RevealPeriodEndedEventArgs = {
558
862
  market: Address;
559
- authority: Address;
863
+ signer: Address;
560
864
  timestamp: number | bigint;
561
865
  };
562
866
  declare function getRevealPeriodEndedEventEncoder(): FixedSizeEncoder<RevealPeriodEndedEventArgs>;
563
867
  declare function getRevealPeriodEndedEventDecoder(): FixedSizeDecoder<RevealPeriodEndedEvent>;
564
868
  declare function getRevealPeriodEndedEventCodec(): FixedSizeCodec<RevealPeriodEndedEventArgs, RevealPeriodEndedEvent>;
565
869
 
870
+ /**
871
+ * This code was AUTOGENERATED using the Codama library.
872
+ * Please DO NOT EDIT THIS FILE, instead use visitors
873
+ * to add features, then rerun Codama to update it.
874
+ *
875
+ * @see https://github.com/codama-idl/codama
876
+ */
877
+
878
+ type RevealStakeFinalizedEvent = {
879
+ owner: Address;
880
+ market: Address;
881
+ stakeAccount: Address;
882
+ stakeAccountId: number;
883
+ optionId: bigint;
884
+ userStake: bigint;
885
+ userScore: bigint;
886
+ totalScore: bigint;
887
+ totalStake: bigint;
888
+ timestamp: bigint;
889
+ };
890
+ type RevealStakeFinalizedEventArgs = {
891
+ owner: Address;
892
+ market: Address;
893
+ stakeAccount: Address;
894
+ stakeAccountId: number;
895
+ optionId: number | bigint;
896
+ userStake: number | bigint;
897
+ userScore: number | bigint;
898
+ totalScore: number | bigint;
899
+ totalStake: number | bigint;
900
+ timestamp: number | bigint;
901
+ };
902
+ declare function getRevealStakeFinalizedEventEncoder(): FixedSizeEncoder<RevealStakeFinalizedEventArgs>;
903
+ declare function getRevealStakeFinalizedEventDecoder(): FixedSizeDecoder<RevealStakeFinalizedEvent>;
904
+ declare function getRevealStakeFinalizedEventCodec(): FixedSizeCodec<RevealStakeFinalizedEventArgs, RevealStakeFinalizedEvent>;
905
+
566
906
  /**
567
907
  * This code was AUTOGENERATED using the Codama library.
568
908
  * Please DO NOT EDIT THIS FILE, instead use visitors
@@ -805,25 +1145,27 @@ declare function getStakeOutputStruct0Codec(): FixedSizeCodec<StakeOutputStruct0
805
1145
  * @see https://github.com/codama-idl/codama
806
1146
  */
807
1147
 
808
- type StakeReclaimedEvent = {
809
- owner: Address;
1148
+ type StakeRevealedEvent = {
1149
+ user: Address;
810
1150
  market: Address;
811
1151
  stakeAccount: Address;
812
1152
  stakeAccountId: number;
813
- amount: bigint;
1153
+ stakeAmount: bigint;
1154
+ selectedOption: bigint;
814
1155
  timestamp: bigint;
815
1156
  };
816
- type StakeReclaimedEventArgs = {
817
- owner: Address;
1157
+ type StakeRevealedEventArgs = {
1158
+ user: Address;
818
1159
  market: Address;
819
1160
  stakeAccount: Address;
820
1161
  stakeAccountId: number;
821
- amount: number | bigint;
1162
+ stakeAmount: number | bigint;
1163
+ selectedOption: number | bigint;
822
1164
  timestamp: number | bigint;
823
1165
  };
824
- declare function getStakeReclaimedEventEncoder(): FixedSizeEncoder<StakeReclaimedEventArgs>;
825
- declare function getStakeReclaimedEventDecoder(): FixedSizeDecoder<StakeReclaimedEvent>;
826
- declare function getStakeReclaimedEventCodec(): FixedSizeCodec<StakeReclaimedEventArgs, StakeReclaimedEvent>;
1166
+ declare function getStakeRevealedEventEncoder(): FixedSizeEncoder<StakeRevealedEventArgs>;
1167
+ declare function getStakeRevealedEventDecoder(): FixedSizeDecoder<StakeRevealedEvent>;
1168
+ declare function getStakeRevealedEventCodec(): FixedSizeCodec<StakeRevealedEventArgs, StakeRevealedEvent>;
827
1169
 
828
1170
  /**
829
1171
  * This code was AUTOGENERATED using the Codama library.
@@ -833,27 +1175,17 @@ declare function getStakeReclaimedEventCodec(): FixedSizeCodec<StakeReclaimedEve
833
1175
  * @see https://github.com/codama-idl/codama
834
1176
  */
835
1177
 
836
- type StakeRevealedEvent = {
837
- user: Address;
1178
+ type StakingPausedEvent = {
838
1179
  market: Address;
839
- stakeAccount: Address;
840
- stakeAccountId: number;
841
- stakeAmount: bigint;
842
- selectedOption: bigint;
843
1180
  timestamp: bigint;
844
1181
  };
845
- type StakeRevealedEventArgs = {
846
- user: Address;
1182
+ type StakingPausedEventArgs = {
847
1183
  market: Address;
848
- stakeAccount: Address;
849
- stakeAccountId: number;
850
- stakeAmount: number | bigint;
851
- selectedOption: number | bigint;
852
1184
  timestamp: number | bigint;
853
1185
  };
854
- declare function getStakeRevealedEventEncoder(): FixedSizeEncoder<StakeRevealedEventArgs>;
855
- declare function getStakeRevealedEventDecoder(): FixedSizeDecoder<StakeRevealedEvent>;
856
- declare function getStakeRevealedEventCodec(): FixedSizeCodec<StakeRevealedEventArgs, StakeRevealedEvent>;
1186
+ declare function getStakingPausedEventEncoder(): FixedSizeEncoder<StakingPausedEventArgs>;
1187
+ declare function getStakingPausedEventDecoder(): FixedSizeDecoder<StakingPausedEvent>;
1188
+ declare function getStakingPausedEventCodec(): FixedSizeCodec<StakingPausedEventArgs, StakingPausedEvent>;
857
1189
 
858
1190
  /**
859
1191
  * This code was AUTOGENERATED using the Codama library.
@@ -863,27 +1195,17 @@ declare function getStakeRevealedEventCodec(): FixedSizeCodec<StakeRevealedEvent
863
1195
  * @see https://github.com/codama-idl/codama
864
1196
  */
865
1197
 
866
- type StuckStakeClosedEvent = {
867
- owner: Address;
1198
+ type StakingResumedEvent = {
868
1199
  market: Address;
869
- stakeAccount: Address;
870
- stakeAccountId: number;
871
- refundedAmount: bigint;
872
- refundedFee: bigint;
873
1200
  timestamp: bigint;
874
1201
  };
875
- type StuckStakeClosedEventArgs = {
876
- owner: Address;
1202
+ type StakingResumedEventArgs = {
877
1203
  market: Address;
878
- stakeAccount: Address;
879
- stakeAccountId: number;
880
- refundedAmount: number | bigint;
881
- refundedFee: number | bigint;
882
1204
  timestamp: number | bigint;
883
1205
  };
884
- declare function getStuckStakeClosedEventEncoder(): FixedSizeEncoder<StuckStakeClosedEventArgs>;
885
- declare function getStuckStakeClosedEventDecoder(): FixedSizeDecoder<StuckStakeClosedEvent>;
886
- declare function getStuckStakeClosedEventCodec(): FixedSizeCodec<StuckStakeClosedEventArgs, StuckStakeClosedEvent>;
1206
+ declare function getStakingResumedEventEncoder(): FixedSizeEncoder<StakingResumedEventArgs>;
1207
+ declare function getStakingResumedEventDecoder(): FixedSizeDecoder<StakingResumedEvent>;
1208
+ declare function getStakingResumedEventCodec(): FixedSizeCodec<StakingResumedEventArgs, StakingResumedEvent>;
887
1209
 
888
1210
  /**
889
1211
  * This code was AUTOGENERATED using the Codama library.
@@ -893,33 +1215,31 @@ declare function getStuckStakeClosedEventCodec(): FixedSizeCodec<StuckStakeClose
893
1215
  * @see https://github.com/codama-idl/codama
894
1216
  */
895
1217
 
896
- type TallyIncrementedEvent = {
1218
+ type StuckStakeClosedEvent = {
897
1219
  owner: Address;
898
1220
  market: Address;
899
1221
  stakeAccount: Address;
900
1222
  stakeAccountId: number;
901
- optionId: bigint;
902
- userStake: bigint;
903
- userScore: bigint;
904
- totalScore: bigint;
905
- totalStake: bigint;
1223
+ refundedAmount: bigint;
1224
+ refundedPlatformFee: bigint;
1225
+ refundedRewardPoolFee: bigint;
1226
+ refundedCreatorFee: bigint;
906
1227
  timestamp: bigint;
907
1228
  };
908
- type TallyIncrementedEventArgs = {
1229
+ type StuckStakeClosedEventArgs = {
909
1230
  owner: Address;
910
1231
  market: Address;
911
1232
  stakeAccount: Address;
912
1233
  stakeAccountId: number;
913
- optionId: number | bigint;
914
- userStake: number | bigint;
915
- userScore: number | bigint;
916
- totalScore: number | bigint;
917
- totalStake: number | bigint;
1234
+ refundedAmount: number | bigint;
1235
+ refundedPlatformFee: number | bigint;
1236
+ refundedRewardPoolFee: number | bigint;
1237
+ refundedCreatorFee: number | bigint;
918
1238
  timestamp: number | bigint;
919
1239
  };
920
- declare function getTallyIncrementedEventEncoder(): FixedSizeEncoder<TallyIncrementedEventArgs>;
921
- declare function getTallyIncrementedEventDecoder(): FixedSizeDecoder<TallyIncrementedEvent>;
922
- declare function getTallyIncrementedEventCodec(): FixedSizeCodec<TallyIncrementedEventArgs, TallyIncrementedEvent>;
1240
+ declare function getStuckStakeClosedEventEncoder(): FixedSizeEncoder<StuckStakeClosedEventArgs>;
1241
+ declare function getStuckStakeClosedEventDecoder(): FixedSizeDecoder<StuckStakeClosedEvent>;
1242
+ declare function getStuckStakeClosedEventCodec(): FixedSizeCodec<StuckStakeClosedEventArgs, StuckStakeClosedEvent>;
923
1243
 
924
1244
  /**
925
1245
  * This code was AUTOGENERATED using the Codama library.
@@ -948,17 +1268,19 @@ declare function getTimestampCodec(): FixedSizeCodec<TimestampArgs, Timestamp>;
948
1268
  */
949
1269
 
950
1270
  type UnstakedEvent = {
951
- user: Address;
1271
+ owner: Address;
952
1272
  market: Address;
953
1273
  stakeAccount: Address;
954
1274
  stakeAccountId: number;
1275
+ amount: bigint;
955
1276
  timestamp: bigint;
956
1277
  };
957
1278
  type UnstakedEventArgs = {
958
- user: Address;
1279
+ owner: Address;
959
1280
  market: Address;
960
1281
  stakeAccount: Address;
961
1282
  stakeAccountId: number;
1283
+ amount: number | bigint;
962
1284
  timestamp: number | bigint;
963
1285
  };
964
1286
  declare function getUnstakedEventEncoder(): FixedSizeEncoder<UnstakedEventArgs>;
@@ -973,25 +1295,21 @@ declare function getUnstakedEventCodec(): FixedSizeCodec<UnstakedEventArgs, Unst
973
1295
  * @see https://github.com/codama-idl/codama
974
1296
  */
975
1297
 
976
- type UnstakeInitiatedEvent = {
977
- user: Address;
978
- market: Address;
979
- stakeAccount: Address;
980
- stakeAccountId: number;
981
- unstakeableAtTimestamp: bigint;
1298
+ type UpdateAuthorityChangedEvent = {
1299
+ platformConfig: Address;
1300
+ oldValue: Address;
1301
+ newValue: Address;
982
1302
  timestamp: bigint;
983
1303
  };
984
- type UnstakeInitiatedEventArgs = {
985
- user: Address;
986
- market: Address;
987
- stakeAccount: Address;
988
- stakeAccountId: number;
989
- unstakeableAtTimestamp: number | bigint;
1304
+ type UpdateAuthorityChangedEventArgs = {
1305
+ platformConfig: Address;
1306
+ oldValue: Address;
1307
+ newValue: Address;
990
1308
  timestamp: number | bigint;
991
1309
  };
992
- declare function getUnstakeInitiatedEventEncoder(): FixedSizeEncoder<UnstakeInitiatedEventArgs>;
993
- declare function getUnstakeInitiatedEventDecoder(): FixedSizeDecoder<UnstakeInitiatedEvent>;
994
- declare function getUnstakeInitiatedEventCodec(): FixedSizeCodec<UnstakeInitiatedEventArgs, UnstakeInitiatedEvent>;
1310
+ declare function getUpdateAuthorityChangedEventEncoder(): FixedSizeEncoder<UpdateAuthorityChangedEventArgs>;
1311
+ declare function getUpdateAuthorityChangedEventDecoder(): FixedSizeDecoder<UpdateAuthorityChangedEvent>;
1312
+ declare function getUpdateAuthorityChangedEventCodec(): FixedSizeCodec<UpdateAuthorityChangedEventArgs, UpdateAuthorityChangedEvent>;
995
1313
 
996
1314
  /**
997
1315
  * This code was AUTOGENERATED using the Codama library.
@@ -1020,254 +1338,27 @@ declare function getUtilityPubkeysCodec(): FixedSizeCodec<UtilityPubkeysArgs, Ut
1020
1338
  * @see https://github.com/codama-idl/codama
1021
1339
  */
1022
1340
 
1023
- type WinningOption = {
1024
- optionId: bigint;
1025
- rewardPercentage: number;
1026
- };
1027
- type WinningOptionArgs = {
1028
- optionId: number | bigint;
1029
- rewardPercentage: number;
1030
- };
1031
- declare function getWinningOptionEncoder(): FixedSizeEncoder<WinningOptionArgs>;
1032
- declare function getWinningOptionDecoder(): FixedSizeDecoder<WinningOption>;
1033
- declare function getWinningOptionCodec(): FixedSizeCodec<WinningOptionArgs, WinningOption>;
1034
-
1035
- /**
1036
- * This code was AUTOGENERATED using the Codama library.
1037
- * Please DO NOT EDIT THIS FILE, instead use visitors
1038
- * to add features, then rerun Codama to update it.
1039
- *
1040
- * @see https://github.com/codama-idl/codama
1041
- */
1042
-
1043
- type WinningOptionsSelectedEvent = {
1341
+ type WinningOptionSetEvent = {
1044
1342
  market: Address;
1045
- authority: Address;
1046
- selectedOptions: Array<WinningOption>;
1343
+ marketAuthority: Address;
1344
+ option: Address;
1345
+ optionId: bigint;
1346
+ rewardPercentageBp: number;
1347
+ winningOptionAllocation: number;
1047
1348
  timestamp: bigint;
1048
1349
  };
1049
- type WinningOptionsSelectedEventArgs = {
1350
+ type WinningOptionSetEventArgs = {
1050
1351
  market: Address;
1051
- authority: Address;
1052
- selectedOptions: Array<WinningOptionArgs>;
1352
+ marketAuthority: Address;
1353
+ option: Address;
1354
+ optionId: number | bigint;
1355
+ rewardPercentageBp: number;
1356
+ winningOptionAllocation: number;
1053
1357
  timestamp: number | bigint;
1054
1358
  };
1055
- declare function getWinningOptionsSelectedEventEncoder(): Encoder<WinningOptionsSelectedEventArgs>;
1056
- declare function getWinningOptionsSelectedEventDecoder(): Decoder<WinningOptionsSelectedEvent>;
1057
- declare function getWinningOptionsSelectedEventCodec(): Codec<WinningOptionsSelectedEventArgs, WinningOptionsSelectedEvent>;
1058
-
1059
- /**
1060
- * This code was AUTOGENERATED using the Codama library.
1061
- * Please DO NOT EDIT THIS FILE, instead use visitors
1062
- * to add features, then rerun Codama to update it.
1063
- *
1064
- * @see https://github.com/codama-idl/codama
1065
- */
1066
-
1067
- declare const CLOCK_ACCOUNT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
1068
- declare function getClockAccountDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
1069
- type ClockAccount = {
1070
- discriminator: ReadonlyUint8Array;
1071
- startEpoch: Epoch;
1072
- currentEpoch: Epoch;
1073
- startEpochTimestamp: Timestamp;
1074
- bump: number;
1075
- };
1076
- type ClockAccountArgs = {
1077
- startEpoch: EpochArgs;
1078
- currentEpoch: EpochArgs;
1079
- startEpochTimestamp: TimestampArgs;
1080
- bump: number;
1081
- };
1082
- declare function getClockAccountEncoder(): FixedSizeEncoder<ClockAccountArgs>;
1083
- declare function getClockAccountDecoder(): FixedSizeDecoder<ClockAccount>;
1084
- declare function getClockAccountCodec(): FixedSizeCodec<ClockAccountArgs, ClockAccount>;
1085
- declare function decodeClockAccount<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<ClockAccount, TAddress>;
1086
- declare function decodeClockAccount<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<ClockAccount, TAddress>;
1087
- declare function fetchClockAccount<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<ClockAccount, TAddress>>;
1088
- declare function fetchMaybeClockAccount<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<ClockAccount, TAddress>>;
1089
- declare function fetchAllClockAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<ClockAccount>[]>;
1090
- declare function fetchAllMaybeClockAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<ClockAccount>[]>;
1091
-
1092
- /**
1093
- * This code was AUTOGENERATED using the Codama library.
1094
- * Please DO NOT EDIT THIS FILE, instead use visitors
1095
- * to add features, then rerun Codama to update it.
1096
- *
1097
- * @see https://github.com/codama-idl/codama
1098
- */
1099
-
1100
- declare const CLUSTER_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
1101
- declare function getClusterDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
1102
- type Cluster = {
1103
- discriminator: ReadonlyUint8Array;
1104
- tdInfo: Option<NodeMetadata>;
1105
- authority: Option<Address>;
1106
- clusterSize: number;
1107
- activation: Activation;
1108
- maxCapacity: bigint;
1109
- cuPrice: bigint;
1110
- cuPriceProposals: Array<bigint>;
1111
- lastUpdatedEpoch: Epoch;
1112
- nodes: Array<NodeRef>;
1113
- pendingNodes: Array<number>;
1114
- blsPublicKey: {
1115
- __kind: 'Set';
1116
- fields: readonly [BN254G2BLSPublicKey];
1117
- } | {
1118
- __kind: 'Unset';
1119
- fields: readonly [BN254G2BLSPublicKey, Array<boolean>];
1120
- };
1121
- bump: number;
1122
- };
1123
- type ClusterArgs = {
1124
- tdInfo: OptionOrNullable<NodeMetadataArgs>;
1125
- authority: OptionOrNullable<Address>;
1126
- clusterSize: number;
1127
- activation: ActivationArgs;
1128
- maxCapacity: number | bigint;
1129
- cuPrice: number | bigint;
1130
- cuPriceProposals: Array<number | bigint>;
1131
- lastUpdatedEpoch: EpochArgs;
1132
- nodes: Array<NodeRefArgs>;
1133
- pendingNodes: Array<number>;
1134
- blsPublicKey: {
1135
- __kind: 'Set';
1136
- fields: readonly [BN254G2BLSPublicKeyArgs];
1137
- } | {
1138
- __kind: 'Unset';
1139
- fields: readonly [BN254G2BLSPublicKeyArgs, Array<boolean>];
1140
- };
1141
- bump: number;
1142
- };
1143
- declare function getClusterEncoder(): Encoder<ClusterArgs>;
1144
- declare function getClusterDecoder(): Decoder<Cluster>;
1145
- declare function getClusterCodec(): Codec<ClusterArgs, Cluster>;
1146
- declare function decodeCluster<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<Cluster, TAddress>;
1147
- declare function decodeCluster<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<Cluster, TAddress>;
1148
- declare function fetchCluster<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<Cluster, TAddress>>;
1149
- declare function fetchMaybeCluster<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<Cluster, TAddress>>;
1150
- declare function fetchAllCluster(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<Cluster>[]>;
1151
- declare function fetchAllMaybeCluster(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<Cluster>[]>;
1152
-
1153
- /**
1154
- * This code was AUTOGENERATED using the Codama library.
1155
- * Please DO NOT EDIT THIS FILE, instead use visitors
1156
- * to add features, then rerun Codama to update it.
1157
- *
1158
- * @see https://github.com/codama-idl/codama
1159
- */
1160
-
1161
- declare const COMPUTATION_DEFINITION_ACCOUNT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
1162
- declare function getComputationDefinitionAccountDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
1163
- type ComputationDefinitionAccount = {
1164
- discriminator: ReadonlyUint8Array;
1165
- finalizationAuthority: Option<Address>;
1166
- cuAmount: bigint;
1167
- definition: ComputationDefinitionMeta;
1168
- circuitSource: CircuitSource;
1169
- bump: number;
1170
- };
1171
- type ComputationDefinitionAccountArgs = {
1172
- finalizationAuthority: OptionOrNullable<Address>;
1173
- cuAmount: number | bigint;
1174
- definition: ComputationDefinitionMetaArgs;
1175
- circuitSource: CircuitSourceArgs;
1176
- bump: number;
1177
- };
1178
- declare function getComputationDefinitionAccountEncoder(): Encoder<ComputationDefinitionAccountArgs>;
1179
- declare function getComputationDefinitionAccountDecoder(): Decoder<ComputationDefinitionAccount>;
1180
- declare function getComputationDefinitionAccountCodec(): Codec<ComputationDefinitionAccountArgs, ComputationDefinitionAccount>;
1181
- declare function decodeComputationDefinitionAccount<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<ComputationDefinitionAccount, TAddress>;
1182
- declare function decodeComputationDefinitionAccount<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<ComputationDefinitionAccount, TAddress>;
1183
- declare function fetchComputationDefinitionAccount<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<ComputationDefinitionAccount, TAddress>>;
1184
- declare function fetchMaybeComputationDefinitionAccount<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<ComputationDefinitionAccount, TAddress>>;
1185
- declare function fetchAllComputationDefinitionAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<ComputationDefinitionAccount>[]>;
1186
- declare function fetchAllMaybeComputationDefinitionAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<ComputationDefinitionAccount>[]>;
1187
-
1188
- /**
1189
- * This code was AUTOGENERATED using the Codama library.
1190
- * Please DO NOT EDIT THIS FILE, instead use visitors
1191
- * to add features, then rerun Codama to update it.
1192
- *
1193
- * @see https://github.com/codama-idl/codama
1194
- */
1195
-
1196
- declare const FEE_POOL_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
1197
- declare function getFeePoolDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
1198
- type FeePool = {
1199
- discriminator: ReadonlyUint8Array;
1200
- bump: number;
1201
- };
1202
- type FeePoolArgs = {
1203
- bump: number;
1204
- };
1205
- declare function getFeePoolEncoder(): FixedSizeEncoder<FeePoolArgs>;
1206
- declare function getFeePoolDecoder(): FixedSizeDecoder<FeePool>;
1207
- declare function getFeePoolCodec(): FixedSizeCodec<FeePoolArgs, FeePool>;
1208
- declare function decodeFeePool<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<FeePool, TAddress>;
1209
- declare function decodeFeePool<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<FeePool, TAddress>;
1210
- declare function fetchFeePool<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<FeePool, TAddress>>;
1211
- declare function fetchMaybeFeePool<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<FeePool, TAddress>>;
1212
- declare function fetchAllFeePool(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<FeePool>[]>;
1213
- declare function fetchAllMaybeFeePool(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<FeePool>[]>;
1214
-
1215
- /**
1216
- * This code was AUTOGENERATED using the Codama library.
1217
- * Please DO NOT EDIT THIS FILE, instead use visitors
1218
- * to add features, then rerun Codama to update it.
1219
- *
1220
- * @see https://github.com/codama-idl/codama
1221
- */
1222
-
1223
- declare const M_X_E_ACCOUNT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
1224
- declare function getMXEAccountDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
1225
- type MXEAccount = {
1226
- discriminator: ReadonlyUint8Array;
1227
- cluster: Option<number>;
1228
- keygenOffset: bigint;
1229
- keyRecoveryInitOffset: bigint;
1230
- mxeProgramId: Address;
1231
- authority: Option<Address>;
1232
- utilityPubkeys: {
1233
- __kind: 'Set';
1234
- fields: readonly [UtilityPubkeys];
1235
- } | {
1236
- __kind: 'Unset';
1237
- fields: readonly [UtilityPubkeys, Array<boolean>];
1238
- };
1239
- lutOffsetSlot: bigint;
1240
- computationDefinitions: Array<number>;
1241
- status: MxeStatus;
1242
- bump: number;
1243
- };
1244
- type MXEAccountArgs = {
1245
- cluster: OptionOrNullable<number>;
1246
- keygenOffset: number | bigint;
1247
- keyRecoveryInitOffset: number | bigint;
1248
- mxeProgramId: Address;
1249
- authority: OptionOrNullable<Address>;
1250
- utilityPubkeys: {
1251
- __kind: 'Set';
1252
- fields: readonly [UtilityPubkeysArgs];
1253
- } | {
1254
- __kind: 'Unset';
1255
- fields: readonly [UtilityPubkeysArgs, Array<boolean>];
1256
- };
1257
- lutOffsetSlot: number | bigint;
1258
- computationDefinitions: Array<number>;
1259
- status: MxeStatusArgs;
1260
- bump: number;
1261
- };
1262
- declare function getMXEAccountEncoder(): Encoder<MXEAccountArgs>;
1263
- declare function getMXEAccountDecoder(): Decoder<MXEAccount>;
1264
- declare function getMXEAccountCodec(): Codec<MXEAccountArgs, MXEAccount>;
1265
- declare function decodeMXEAccount<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<MXEAccount, TAddress>;
1266
- declare function decodeMXEAccount<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<MXEAccount, TAddress>;
1267
- declare function fetchMXEAccount<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<MXEAccount, TAddress>>;
1268
- declare function fetchMaybeMXEAccount<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<MXEAccount, TAddress>>;
1269
- declare function fetchAllMXEAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<MXEAccount>[]>;
1270
- declare function fetchAllMaybeMXEAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<MXEAccount>[]>;
1359
+ declare function getWinningOptionSetEventEncoder(): FixedSizeEncoder<WinningOptionSetEventArgs>;
1360
+ declare function getWinningOptionSetEventDecoder(): FixedSizeDecoder<WinningOptionSetEvent>;
1361
+ declare function getWinningOptionSetEventCodec(): FixedSizeCodec<WinningOptionSetEventArgs, WinningOptionSetEvent>;
1271
1362
 
1272
1363
  /**
1273
1364
  * This code was AUTOGENERATED using the Codama library.
@@ -1285,38 +1376,56 @@ type OpportunityMarket = {
1285
1376
  creator: Address;
1286
1377
  index: bigint;
1287
1378
  totalOptions: bigint;
1288
- openTimestamp: Option<bigint>;
1289
- timeToStake: bigint;
1290
- timeToReveal: bigint;
1291
- selectedOptions: Option<Array<WinningOption>>;
1379
+ platform: Address;
1380
+ stakeEndTimestamp: Option<bigint>;
1381
+ resolvedAtTimestamp: Option<bigint>;
1382
+ winningOptionAllocation: number;
1292
1383
  rewardAmount: bigint;
1293
1384
  marketAuthority: Address;
1294
1385
  revealPeriodAuthority: Address;
1295
1386
  mint: Address;
1296
1387
  earlinessCutoffSeconds: bigint;
1297
- unstakeDelaySeconds: bigint;
1388
+ earlinessMultiplier: number;
1389
+ allowUnstakingEarly: boolean;
1298
1390
  authorizedReaderPubkey: Array<number>;
1299
- allowClosingEarly: boolean;
1300
- paused: boolean;
1391
+ stakingPaused: boolean;
1392
+ feeRates: FeeRates;
1393
+ collectedPlatformFees: bigint;
1394
+ collectedCreatorFees: bigint;
1395
+ creatorFeeClaimer: Address;
1396
+ marketResolutionDeadlineSeconds: bigint;
1397
+ minRevealPeriodSeconds: bigint;
1398
+ maxRevealPeriodSeconds: bigint;
1399
+ revealEnded: boolean;
1400
+ minStakeAmount: bigint;
1301
1401
  };
1302
1402
  type OpportunityMarketArgs = {
1303
1403
  bump: number;
1304
1404
  creator: Address;
1305
1405
  index: number | bigint;
1306
1406
  totalOptions: number | bigint;
1307
- openTimestamp: OptionOrNullable<number | bigint>;
1308
- timeToStake: number | bigint;
1309
- timeToReveal: number | bigint;
1310
- selectedOptions: OptionOrNullable<Array<WinningOptionArgs>>;
1407
+ platform: Address;
1408
+ stakeEndTimestamp: OptionOrNullable<number | bigint>;
1409
+ resolvedAtTimestamp: OptionOrNullable<number | bigint>;
1410
+ winningOptionAllocation: number;
1311
1411
  rewardAmount: number | bigint;
1312
1412
  marketAuthority: Address;
1313
1413
  revealPeriodAuthority: Address;
1314
1414
  mint: Address;
1315
1415
  earlinessCutoffSeconds: number | bigint;
1316
- unstakeDelaySeconds: number | bigint;
1416
+ earlinessMultiplier: number;
1417
+ allowUnstakingEarly: boolean;
1317
1418
  authorizedReaderPubkey: Array<number>;
1318
- allowClosingEarly: boolean;
1319
- paused: boolean;
1419
+ stakingPaused: boolean;
1420
+ feeRates: FeeRatesArgs;
1421
+ collectedPlatformFees: number | bigint;
1422
+ collectedCreatorFees: number | bigint;
1423
+ creatorFeeClaimer: Address;
1424
+ marketResolutionDeadlineSeconds: number | bigint;
1425
+ minRevealPeriodSeconds: number | bigint;
1426
+ maxRevealPeriodSeconds: number | bigint;
1427
+ revealEnded: boolean;
1428
+ minStakeAmount: number | bigint;
1320
1429
  };
1321
1430
  declare function getOpportunityMarketEncoder(): Encoder<OpportunityMarketArgs>;
1322
1431
  declare function getOpportunityMarketDecoder(): Decoder<OpportunityMarket>;
@@ -1342,18 +1451,24 @@ type OpportunityMarketOption = {
1342
1451
  discriminator: ReadonlyUint8Array;
1343
1452
  bump: number;
1344
1453
  id: bigint;
1454
+ creator: Address;
1455
+ createdAt: bigint;
1345
1456
  totalStaked: bigint;
1346
1457
  totalScore: bigint;
1458
+ rewardPercentageBp: Option<number>;
1347
1459
  };
1348
1460
  type OpportunityMarketOptionArgs = {
1349
1461
  bump: number;
1350
1462
  id: number | bigint;
1463
+ creator: Address;
1464
+ createdAt: number | bigint;
1351
1465
  totalStaked: number | bigint;
1352
1466
  totalScore: number | bigint;
1467
+ rewardPercentageBp: OptionOrNullable<number>;
1353
1468
  };
1354
- declare function getOpportunityMarketOptionEncoder(): FixedSizeEncoder<OpportunityMarketOptionArgs>;
1355
- declare function getOpportunityMarketOptionDecoder(): FixedSizeDecoder<OpportunityMarketOption>;
1356
- declare function getOpportunityMarketOptionCodec(): FixedSizeCodec<OpportunityMarketOptionArgs, OpportunityMarketOption>;
1469
+ declare function getOpportunityMarketOptionEncoder(): Encoder<OpportunityMarketOptionArgs>;
1470
+ declare function getOpportunityMarketOptionDecoder(): Decoder<OpportunityMarketOption>;
1471
+ declare function getOpportunityMarketOptionCodec(): Codec<OpportunityMarketOptionArgs, OpportunityMarketOption>;
1357
1472
  declare function decodeOpportunityMarketOption<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<OpportunityMarketOption, TAddress>;
1358
1473
  declare function decodeOpportunityMarketOption<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<OpportunityMarketOption, TAddress>;
1359
1474
  declare function fetchOpportunityMarketOption<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<OpportunityMarketOption, TAddress>>;
@@ -1396,6 +1511,49 @@ declare function fetchMaybeOpportunityMarketSponsor<TAddress extends string = st
1396
1511
  declare function fetchAllOpportunityMarketSponsor(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<OpportunityMarketSponsor>[]>;
1397
1512
  declare function fetchAllMaybeOpportunityMarketSponsor(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<OpportunityMarketSponsor>[]>;
1398
1513
 
1514
+ /**
1515
+ * This code was AUTOGENERATED using the Codama library.
1516
+ * Please DO NOT EDIT THIS FILE, instead use visitors
1517
+ * to add features, then rerun Codama to update it.
1518
+ *
1519
+ * @see https://github.com/codama-idl/codama
1520
+ */
1521
+
1522
+ declare const PLATFORM_CONFIG_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
1523
+ declare function getPlatformConfigDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
1524
+ type PlatformConfig = {
1525
+ discriminator: ReadonlyUint8Array;
1526
+ bump: number;
1527
+ name: string;
1528
+ updateAuthority: Address;
1529
+ feeClaimAuthority: Address;
1530
+ feeRates: FeeRates;
1531
+ marketResolutionDeadlineSeconds: bigint;
1532
+ minTimeToStakeSeconds: bigint;
1533
+ minRevealPeriodSeconds: bigint;
1534
+ maxRevealPeriodSeconds: bigint;
1535
+ };
1536
+ type PlatformConfigArgs = {
1537
+ bump: number;
1538
+ name: string;
1539
+ updateAuthority: Address;
1540
+ feeClaimAuthority: Address;
1541
+ feeRates: FeeRatesArgs;
1542
+ marketResolutionDeadlineSeconds: number | bigint;
1543
+ minTimeToStakeSeconds: number | bigint;
1544
+ minRevealPeriodSeconds: number | bigint;
1545
+ maxRevealPeriodSeconds: number | bigint;
1546
+ };
1547
+ declare function getPlatformConfigEncoder(): Encoder<PlatformConfigArgs>;
1548
+ declare function getPlatformConfigDecoder(): Decoder<PlatformConfig>;
1549
+ declare function getPlatformConfigCodec(): Codec<PlatformConfigArgs, PlatformConfig>;
1550
+ declare function decodePlatformConfig<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<PlatformConfig, TAddress>;
1551
+ declare function decodePlatformConfig<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<PlatformConfig, TAddress>;
1552
+ declare function fetchPlatformConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<PlatformConfig, TAddress>>;
1553
+ declare function fetchMaybePlatformConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<PlatformConfig, TAddress>>;
1554
+ declare function fetchAllPlatformConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<PlatformConfig>[]>;
1555
+ declare function fetchAllMaybePlatformConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<PlatformConfig>[]>;
1556
+
1399
1557
  /**
1400
1558
  * This code was AUTOGENERATED using the Codama library.
1401
1559
  * Please DO NOT EDIT THIS FILE, instead use visitors
@@ -1419,16 +1577,13 @@ type StakeAccount = {
1419
1577
  stakedAtTimestamp: Option<bigint>;
1420
1578
  unstakedAtTimestamp: Option<bigint>;
1421
1579
  amount: bigint;
1422
- fee: bigint;
1580
+ collectedFees: CollectedFees;
1423
1581
  revealedOption: Option<bigint>;
1424
1582
  score: Option<bigint>;
1425
- totalIncremented: boolean;
1426
- unstakeableAtTimestamp: Option<bigint>;
1427
- locked: boolean;
1428
- stakeReclaimed: boolean;
1429
- pendingStake: boolean;
1430
- pendingReveal: boolean;
1583
+ unstaked: boolean;
1431
1584
  id: number;
1585
+ pendingStakeComputation: Option<Address>;
1586
+ pendingReveal: boolean;
1432
1587
  };
1433
1588
  type StakeAccountArgs = {
1434
1589
  encryptedOption: Array<number>;
@@ -1442,16 +1597,13 @@ type StakeAccountArgs = {
1442
1597
  stakedAtTimestamp: OptionOrNullable<number | bigint>;
1443
1598
  unstakedAtTimestamp: OptionOrNullable<number | bigint>;
1444
1599
  amount: number | bigint;
1445
- fee: number | bigint;
1600
+ collectedFees: CollectedFeesArgs;
1446
1601
  revealedOption: OptionOrNullable<number | bigint>;
1447
1602
  score: OptionOrNullable<number | bigint>;
1448
- totalIncremented: boolean;
1449
- unstakeableAtTimestamp: OptionOrNullable<number | bigint>;
1450
- locked: boolean;
1451
- stakeReclaimed: boolean;
1452
- pendingStake: boolean;
1453
- pendingReveal: boolean;
1603
+ unstaked: boolean;
1454
1604
  id: number;
1605
+ pendingStakeComputation: OptionOrNullable<Address>;
1606
+ pendingReveal: boolean;
1455
1607
  };
1456
1608
  declare function getStakeAccountEncoder(): Encoder<StakeAccountArgs>;
1457
1609
  declare function getStakeAccountDecoder(): Decoder<StakeAccount>;
@@ -1463,43 +1615,6 @@ declare function fetchMaybeStakeAccount<TAddress extends string = string>(rpc: P
1463
1615
  declare function fetchAllStakeAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<StakeAccount>[]>;
1464
1616
  declare function fetchAllMaybeStakeAccount(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<StakeAccount>[]>;
1465
1617
 
1466
- /**
1467
- * This code was AUTOGENERATED using the Codama library.
1468
- * Please DO NOT EDIT THIS FILE, instead use visitors
1469
- * to add features, then rerun Codama to update it.
1470
- *
1471
- * @see https://github.com/codama-idl/codama
1472
- */
1473
-
1474
- declare const TOKEN_VAULT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
1475
- declare function getTokenVaultDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
1476
- type TokenVault = {
1477
- discriminator: ReadonlyUint8Array;
1478
- bump: number;
1479
- mint: Address;
1480
- collectedFees: bigint;
1481
- protocolFeeBp: number;
1482
- /** Reserved for future use */
1483
- reserved: Array<number>;
1484
- };
1485
- type TokenVaultArgs = {
1486
- bump: number;
1487
- mint: Address;
1488
- collectedFees: number | bigint;
1489
- protocolFeeBp: number;
1490
- /** Reserved for future use */
1491
- reserved: Array<number>;
1492
- };
1493
- declare function getTokenVaultEncoder(): FixedSizeEncoder<TokenVaultArgs>;
1494
- declare function getTokenVaultDecoder(): FixedSizeDecoder<TokenVault>;
1495
- declare function getTokenVaultCodec(): FixedSizeCodec<TokenVaultArgs, TokenVault>;
1496
- declare function decodeTokenVault<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<TokenVault, TAddress>;
1497
- declare function decodeTokenVault<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<TokenVault, TAddress>;
1498
- declare function fetchTokenVault<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<TokenVault, TAddress>>;
1499
- declare function fetchMaybeTokenVault<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<TokenVault, TAddress>>;
1500
- declare function fetchAllTokenVault(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<TokenVault>[]>;
1501
- declare function fetchAllMaybeTokenVault(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<TokenVault>[]>;
1502
-
1503
1618
  /**
1504
1619
  * This code was AUTOGENERATED using the Codama library.
1505
1620
  * Please DO NOT EDIT THIS FILE, instead use visitors
@@ -1510,24 +1625,24 @@ declare function fetchAllMaybeTokenVault(rpc: Parameters<typeof fetchEncodedAcco
1510
1625
 
1511
1626
  /** AbortedComputation: Computation aborted */
1512
1627
  declare const OPPORTUNITY_MARKET_ERROR__ABORTED_COMPUTATION = 6000;
1513
- /** ClusterNotSet: Cluster not set */
1514
- declare const OPPORTUNITY_MARKET_ERROR__CLUSTER_NOT_SET = 6001;
1515
1628
  /** Unauthorized: Unauthorized */
1516
- declare const OPPORTUNITY_MARKET_ERROR__UNAUTHORIZED = 6002;
1629
+ declare const OPPORTUNITY_MARKET_ERROR__UNAUTHORIZED = 6001;
1517
1630
  /** InsufficientBalance: Insufficient balance */
1518
- declare const OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_BALANCE = 6003;
1631
+ declare const OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_BALANCE = 6002;
1519
1632
  /** InsufficientRewardFunding: Insufficient reward funding */
1520
- declare const OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_REWARD_FUNDING = 6004;
1521
- /** InvalidTimestamp: Timestamp must be in the future */
1522
- declare const OPPORTUNITY_MARKET_ERROR__INVALID_TIMESTAMP = 6005;
1633
+ declare const OPPORTUNITY_MARKET_ERROR__INSUFFICIENT_REWARD_FUNDING = 6003;
1634
+ /** InvalidParameters: Invalid parameters */
1635
+ declare const OPPORTUNITY_MARKET_ERROR__INVALID_PARAMETERS = 6004;
1523
1636
  /** MarketAlreadyOpen: Market is already open */
1524
- declare const OPPORTUNITY_MARKET_ERROR__MARKET_ALREADY_OPEN = 6006;
1637
+ declare const OPPORTUNITY_MARKET_ERROR__MARKET_ALREADY_OPEN = 6005;
1525
1638
  /** InvalidOptionId: Invalid option ID */
1526
- declare const OPPORTUNITY_MARKET_ERROR__INVALID_OPTION_ID = 6007;
1639
+ declare const OPPORTUNITY_MARKET_ERROR__INVALID_OPTION_ID = 6006;
1527
1640
  /** MarketNotOpen: Market is not open */
1528
- declare const OPPORTUNITY_MARKET_ERROR__MARKET_NOT_OPEN = 6008;
1529
- /** StakingNotActive: Staking period is not active */
1530
- declare const OPPORTUNITY_MARKET_ERROR__STAKING_NOT_ACTIVE = 6009;
1641
+ declare const OPPORTUNITY_MARKET_ERROR__MARKET_NOT_OPEN = 6007;
1642
+ /** TimeWindowMismatch: Operation called outside its permitted time window */
1643
+ declare const OPPORTUNITY_MARKET_ERROR__TIME_WINDOW_MISMATCH = 6008;
1644
+ /** NoStake: Stake account has no recorded stake */
1645
+ declare const OPPORTUNITY_MARKET_ERROR__NO_STAKE = 6009;
1531
1646
  /** WinnerAlreadySelected: Market winner already selected */
1532
1647
  declare const OPPORTUNITY_MARKET_ERROR__WINNER_ALREADY_SELECTED = 6010;
1533
1648
  /** AlreadyRevealed: Stake already revealed */
@@ -1556,27 +1671,31 @@ declare const OPPORTUNITY_MARKET_ERROR__ADD_OPTION_STAKE_FAILED = 6021;
1556
1671
  declare const OPPORTUNITY_MARKET_ERROR__LOCKED = 6022;
1557
1672
  /** InvalidAccountState: Invalid account state */
1558
1673
  declare const OPPORTUNITY_MARKET_ERROR__INVALID_ACCOUNT_STATE = 6023;
1559
- /** UnstakeDelayNotMet: Unstake delay period has not passed yet */
1560
- declare const OPPORTUNITY_MARKET_ERROR__UNSTAKE_DELAY_NOT_MET = 6024;
1561
- /** UnstakeNotInitiated: Unstake has not been initiated */
1562
- declare const OPPORTUNITY_MARKET_ERROR__UNSTAKE_NOT_INITIATED = 6025;
1563
- /** ClosingEarlyNotAllowed: Market cannot be closed before stake period ends */
1564
- declare const OPPORTUNITY_MARKET_ERROR__CLOSING_EARLY_NOT_ALLOWED = 6026;
1565
1674
  /** NoFeesToClaim: No fees to claim */
1566
- declare const OPPORTUNITY_MARKET_ERROR__NO_FEES_TO_CLAIM = 6027;
1567
- /** InvalidWinningOptionsInput: Invalid winning options input */
1568
- declare const OPPORTUNITY_MARKET_ERROR__INVALID_WINNING_OPTIONS_INPUT = 6028;
1675
+ declare const OPPORTUNITY_MARKET_ERROR__NO_FEES_TO_CLAIM = 6024;
1569
1676
  /** StakeNotStuck: Stake account is not in a stuck or failed state */
1570
- declare const OPPORTUNITY_MARKET_ERROR__STAKE_NOT_STUCK = 6029;
1571
- /** ProtocolFeeTooHigh: Protocol fee exceeds maximum 500 bp */
1572
- declare const OPPORTUNITY_MARKET_ERROR__PROTOCOL_FEE_TOO_HIGH = 6030;
1677
+ declare const OPPORTUNITY_MARKET_ERROR__STAKE_NOT_STUCK = 6025;
1573
1678
  /** MarketPaused: Market staking is currently paused */
1574
- declare const OPPORTUNITY_MARKET_ERROR__MARKET_PAUSED = 6031;
1679
+ declare const OPPORTUNITY_MARKET_ERROR__MARKET_PAUSED = 6026;
1575
1680
  /** MarketNotPaused: Market is not paused */
1576
- declare const OPPORTUNITY_MARKET_ERROR__MARKET_NOT_PAUSED = 6032;
1577
- /** EarlinessCutoffTooLarge: Earliness cutoff exceeds staking period */
1578
- declare const OPPORTUNITY_MARKET_ERROR__EARLINESS_CUTOFF_TOO_LARGE = 6033;
1579
- 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__UNAUTHORIZED | typeof OPPORTUNITY_MARKET_ERROR__UNSTAKE_DELAY_NOT_MET | typeof OPPORTUNITY_MARKET_ERROR__UNSTAKE_NOT_INITIATED | typeof OPPORTUNITY_MARKET_ERROR__WINNER_ALREADY_SELECTED;
1681
+ declare const OPPORTUNITY_MARKET_ERROR__MARKET_NOT_PAUSED = 6027;
1682
+ /** StakeBelowMinimum: Stake amount is below the market minimum */
1683
+ declare const OPPORTUNITY_MARKET_ERROR__STAKE_BELOW_MINIMUM = 6028;
1684
+ /** SelectOptionsDeadlinePassed: Deadline for selecting winning options has passed */
1685
+ declare const OPPORTUNITY_MARKET_ERROR__SELECT_OPTIONS_DEADLINE_PASSED = 6029;
1686
+ /** InvalidFeeRates: Invalid fee rates */
1687
+ declare const OPPORTUNITY_MARKET_ERROR__INVALID_FEE_RATES = 6030;
1688
+ /** OptionStillNeeded: Option still needed */
1689
+ declare const OPPORTUNITY_MARKET_ERROR__OPTION_STILL_NEEDED = 6031;
1690
+ /** CreatorMismatch: Creator mismatch */
1691
+ declare const OPPORTUNITY_MARKET_ERROR__CREATOR_MISMATCH = 6032;
1692
+ /** RevealPeriodNotOver: Reveal period not over */
1693
+ declare const OPPORTUNITY_MARKET_ERROR__REVEAL_PERIOD_NOT_OVER = 6033;
1694
+ /** NoRewardToClaim: No reward to claim */
1695
+ declare const OPPORTUNITY_MARKET_ERROR__NO_REWARD_TO_CLAIM = 6034;
1696
+ /** RewardAlreadyClaimed: Reward already claimed */
1697
+ declare const OPPORTUNITY_MARKET_ERROR__REWARD_ALREADY_CLAIMED = 6035;
1698
+ 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;
1580
1699
  declare function getOpportunityMarketErrorMessage(code: OpportunityMarketError): string;
1581
1700
  declare function isOpportunityMarketError<TProgramErrorCode extends OpportunityMarketError>(error: unknown, transactionMessage: {
1582
1701
  instructions: Record<number, {
@@ -1596,20 +1715,15 @@ declare function isOpportunityMarketError<TProgramErrorCode extends OpportunityM
1596
1715
  * @see https://github.com/codama-idl/codama
1597
1716
  */
1598
1717
 
1599
- declare const OPPORTUNITY_MARKET_PROGRAM_ADDRESS: Address<"BENCHauvSzMY39khAvj43LHRpbVewb76Wv8ETsVuHn8C">;
1718
+ declare const OPPORTUNITY_MARKET_PROGRAM_ADDRESS: Address<"B3NCHsGBkdZrPYPJY2rjg4UwmyRotMmFWhxa5hMHwLeg">;
1600
1719
  declare enum OpportunityMarketAccount {
1601
- ArciumSignerAccount = 0,
1602
- CentralState = 1,
1603
- ClockAccount = 2,
1604
- Cluster = 3,
1605
- ComputationDefinitionAccount = 4,
1606
- FeePool = 5,
1607
- MXEAccount = 6,
1608
- OpportunityMarket = 7,
1609
- OpportunityMarketOption = 8,
1610
- OpportunityMarketSponsor = 9,
1611
- StakeAccount = 10,
1612
- TokenVault = 11
1720
+ AllowedMint = 0,
1721
+ ArciumSignerAccount = 1,
1722
+ OpportunityMarket = 2,
1723
+ OpportunityMarketOption = 3,
1724
+ OpportunityMarketSponsor = 4,
1725
+ PlatformConfig = 5,
1726
+ StakeAccount = 6
1613
1727
  }
1614
1728
  declare function identifyOpportunityMarketAccount(account: {
1615
1729
  data: ReadonlyUint8Array;
@@ -1617,88 +1731,94 @@ declare function identifyOpportunityMarketAccount(account: {
1617
1731
  declare enum OpportunityMarketInstruction {
1618
1732
  AddMarketOption = 0,
1619
1733
  AddReward = 1,
1620
- ClaimFees = 2,
1621
- CloseStakeAccount = 3,
1622
- CloseStuckStakeAccount = 4,
1623
- CreateMarket = 5,
1624
- DoUnstakeEarly = 6,
1625
- EndRevealPeriod = 7,
1626
- IncrementOptionTally = 8,
1627
- InitCentralState = 9,
1628
- InitStakeAccount = 10,
1629
- InitTokenVault = 11,
1630
- OpenMarket = 12,
1631
- PauseMarket = 13,
1632
- ReclaimStake = 14,
1633
- ResumeMarket = 15,
1634
- RevealStake = 16,
1635
- RevealStakeCallback = 17,
1636
- RevealStakeCompDef = 18,
1637
- SelectWinningOptions = 19,
1638
- Stake = 20,
1639
- StakeCallback = 21,
1640
- StakeCompDef = 22,
1641
- TransferCentralStateAuthority = 23,
1642
- UnstakeEarly = 24,
1643
- UpdateCentralState = 25,
1644
- WithdrawReward = 26
1734
+ ClaimCreatorFees = 2,
1735
+ ClaimFees = 3,
1736
+ CloseOptionAccount = 4,
1737
+ CloseStakeAccount = 5,
1738
+ CloseStuckStakeAccount = 6,
1739
+ CreateMarket = 7,
1740
+ EndRevealPeriod = 8,
1741
+ FinalizeRevealStake = 9,
1742
+ InitAllowedMint = 10,
1743
+ InitPlatformConfig = 11,
1744
+ InitStakeAccount = 12,
1745
+ OpenMarket = 13,
1746
+ PauseStaking = 14,
1747
+ ResolveMarket = 15,
1748
+ ResumeStaking = 16,
1749
+ RevealStake = 17,
1750
+ RevealStakeCallback = 18,
1751
+ RevealStakeCompDef = 19,
1752
+ SetFeeClaimAuthority = 20,
1753
+ SetUpdateAuthority = 21,
1754
+ SetWinningOption = 22,
1755
+ Stake = 23,
1756
+ StakeCallback = 24,
1757
+ StakeCompDef = 25,
1758
+ Unstake = 26,
1759
+ UpdatePlatformConfig = 27,
1760
+ WithdrawReward = 28
1645
1761
  }
1646
1762
  declare function identifyOpportunityMarketInstruction(instruction: {
1647
1763
  data: ReadonlyUint8Array;
1648
1764
  } | ReadonlyUint8Array): OpportunityMarketInstruction;
1649
- type ParsedOpportunityMarketInstruction<TProgram extends string = 'BENCHauvSzMY39khAvj43LHRpbVewb76Wv8ETsVuHn8C'> = ({
1765
+ type ParsedOpportunityMarketInstruction<TProgram extends string = 'B3NCHsGBkdZrPYPJY2rjg4UwmyRotMmFWhxa5hMHwLeg'> = ({
1650
1766
  instructionType: OpportunityMarketInstruction.AddMarketOption;
1651
1767
  } & ParsedAddMarketOptionInstruction<TProgram>) | ({
1652
1768
  instructionType: OpportunityMarketInstruction.AddReward;
1653
1769
  } & ParsedAddRewardInstruction<TProgram>) | ({
1770
+ instructionType: OpportunityMarketInstruction.ClaimCreatorFees;
1771
+ } & ParsedClaimCreatorFeesInstruction<TProgram>) | ({
1654
1772
  instructionType: OpportunityMarketInstruction.ClaimFees;
1655
1773
  } & ParsedClaimFeesInstruction<TProgram>) | ({
1774
+ instructionType: OpportunityMarketInstruction.CloseOptionAccount;
1775
+ } & ParsedCloseOptionAccountInstruction<TProgram>) | ({
1656
1776
  instructionType: OpportunityMarketInstruction.CloseStakeAccount;
1657
1777
  } & ParsedCloseStakeAccountInstruction<TProgram>) | ({
1658
1778
  instructionType: OpportunityMarketInstruction.CloseStuckStakeAccount;
1659
1779
  } & ParsedCloseStuckStakeAccountInstruction<TProgram>) | ({
1660
1780
  instructionType: OpportunityMarketInstruction.CreateMarket;
1661
1781
  } & ParsedCreateMarketInstruction<TProgram>) | ({
1662
- instructionType: OpportunityMarketInstruction.DoUnstakeEarly;
1663
- } & ParsedDoUnstakeEarlyInstruction<TProgram>) | ({
1664
1782
  instructionType: OpportunityMarketInstruction.EndRevealPeriod;
1665
1783
  } & ParsedEndRevealPeriodInstruction<TProgram>) | ({
1666
- instructionType: OpportunityMarketInstruction.IncrementOptionTally;
1667
- } & ParsedIncrementOptionTallyInstruction<TProgram>) | ({
1668
- instructionType: OpportunityMarketInstruction.InitCentralState;
1669
- } & ParsedInitCentralStateInstruction<TProgram>) | ({
1784
+ instructionType: OpportunityMarketInstruction.FinalizeRevealStake;
1785
+ } & ParsedFinalizeRevealStakeInstruction<TProgram>) | ({
1786
+ instructionType: OpportunityMarketInstruction.InitAllowedMint;
1787
+ } & ParsedInitAllowedMintInstruction<TProgram>) | ({
1788
+ instructionType: OpportunityMarketInstruction.InitPlatformConfig;
1789
+ } & ParsedInitPlatformConfigInstruction<TProgram>) | ({
1670
1790
  instructionType: OpportunityMarketInstruction.InitStakeAccount;
1671
1791
  } & ParsedInitStakeAccountInstruction<TProgram>) | ({
1672
- instructionType: OpportunityMarketInstruction.InitTokenVault;
1673
- } & ParsedInitTokenVaultInstruction<TProgram>) | ({
1674
1792
  instructionType: OpportunityMarketInstruction.OpenMarket;
1675
1793
  } & ParsedOpenMarketInstruction<TProgram>) | ({
1676
- instructionType: OpportunityMarketInstruction.PauseMarket;
1677
- } & ParsedPauseMarketInstruction<TProgram>) | ({
1678
- instructionType: OpportunityMarketInstruction.ReclaimStake;
1679
- } & ParsedReclaimStakeInstruction<TProgram>) | ({
1680
- instructionType: OpportunityMarketInstruction.ResumeMarket;
1681
- } & ParsedResumeMarketInstruction<TProgram>) | ({
1794
+ instructionType: OpportunityMarketInstruction.PauseStaking;
1795
+ } & ParsedPauseStakingInstruction<TProgram>) | ({
1796
+ instructionType: OpportunityMarketInstruction.ResolveMarket;
1797
+ } & ParsedResolveMarketInstruction<TProgram>) | ({
1798
+ instructionType: OpportunityMarketInstruction.ResumeStaking;
1799
+ } & ParsedResumeStakingInstruction<TProgram>) | ({
1682
1800
  instructionType: OpportunityMarketInstruction.RevealStake;
1683
1801
  } & ParsedRevealStakeInstruction<TProgram>) | ({
1684
1802
  instructionType: OpportunityMarketInstruction.RevealStakeCallback;
1685
1803
  } & ParsedRevealStakeCallbackInstruction<TProgram>) | ({
1686
1804
  instructionType: OpportunityMarketInstruction.RevealStakeCompDef;
1687
1805
  } & ParsedRevealStakeCompDefInstruction<TProgram>) | ({
1688
- instructionType: OpportunityMarketInstruction.SelectWinningOptions;
1689
- } & ParsedSelectWinningOptionsInstruction<TProgram>) | ({
1806
+ instructionType: OpportunityMarketInstruction.SetFeeClaimAuthority;
1807
+ } & ParsedSetFeeClaimAuthorityInstruction<TProgram>) | ({
1808
+ instructionType: OpportunityMarketInstruction.SetUpdateAuthority;
1809
+ } & ParsedSetUpdateAuthorityInstruction<TProgram>) | ({
1810
+ instructionType: OpportunityMarketInstruction.SetWinningOption;
1811
+ } & ParsedSetWinningOptionInstruction<TProgram>) | ({
1690
1812
  instructionType: OpportunityMarketInstruction.Stake;
1691
1813
  } & ParsedStakeInstruction<TProgram>) | ({
1692
1814
  instructionType: OpportunityMarketInstruction.StakeCallback;
1693
1815
  } & ParsedStakeCallbackInstruction<TProgram>) | ({
1694
1816
  instructionType: OpportunityMarketInstruction.StakeCompDef;
1695
1817
  } & ParsedStakeCompDefInstruction<TProgram>) | ({
1696
- instructionType: OpportunityMarketInstruction.TransferCentralStateAuthority;
1697
- } & ParsedTransferCentralStateAuthorityInstruction<TProgram>) | ({
1698
- instructionType: OpportunityMarketInstruction.UnstakeEarly;
1699
- } & ParsedUnstakeEarlyInstruction<TProgram>) | ({
1700
- instructionType: OpportunityMarketInstruction.UpdateCentralState;
1701
- } & ParsedUpdateCentralStateInstruction<TProgram>) | ({
1818
+ instructionType: OpportunityMarketInstruction.Unstake;
1819
+ } & ParsedUnstakeInstruction<TProgram>) | ({
1820
+ instructionType: OpportunityMarketInstruction.UpdatePlatformConfig;
1821
+ } & ParsedUpdatePlatformConfigInstruction<TProgram>) | ({
1702
1822
  instructionType: OpportunityMarketInstruction.WithdrawReward;
1703
1823
  } & ParsedWithdrawRewardInstruction<TProgram>);
1704
1824
 
@@ -1712,8 +1832,8 @@ type ParsedOpportunityMarketInstruction<TProgram extends string = 'BENCHauvSzMY3
1712
1832
 
1713
1833
  declare const ADD_MARKET_OPTION_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
1714
1834
  declare function getAddMarketOptionDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
1715
- 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<[
1716
- TAccountCreator extends string ? WritableSignerAccount<TAccountCreator> & AccountSignerMeta<TAccountCreator> : TAccountCreator,
1835
+ 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<[
1836
+ TAccountSigner extends string ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
1717
1837
  TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
1718
1838
  TAccountOption extends string ? WritableAccount<TAccountOption> : TAccountOption,
1719
1839
  TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
@@ -1729,30 +1849,30 @@ type AddMarketOptionInstructionDataArgs = {
1729
1849
  declare function getAddMarketOptionInstructionDataEncoder(): FixedSizeEncoder<AddMarketOptionInstructionDataArgs>;
1730
1850
  declare function getAddMarketOptionInstructionDataDecoder(): FixedSizeDecoder<AddMarketOptionInstructionData>;
1731
1851
  declare function getAddMarketOptionInstructionDataCodec(): FixedSizeCodec<AddMarketOptionInstructionDataArgs, AddMarketOptionInstructionData>;
1732
- type AddMarketOptionAsyncInput<TAccountCreator extends string = string, TAccountMarket extends string = string, TAccountOption extends string = string, TAccountSystemProgram extends string = string> = {
1733
- creator: TransactionSigner<TAccountCreator>;
1852
+ type AddMarketOptionAsyncInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountOption extends string = string, TAccountSystemProgram extends string = string> = {
1853
+ signer: TransactionSigner<TAccountSigner>;
1734
1854
  market: Address<TAccountMarket>;
1735
1855
  option?: Address<TAccountOption>;
1736
1856
  systemProgram?: Address<TAccountSystemProgram>;
1737
1857
  optionId: AddMarketOptionInstructionDataArgs['optionId'];
1738
1858
  };
1739
- 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?: {
1859
+ 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?: {
1740
1860
  programAddress?: TProgramAddress;
1741
- }): Promise<AddMarketOptionInstruction<TProgramAddress, TAccountCreator, TAccountMarket, TAccountOption, TAccountSystemProgram>>;
1742
- type AddMarketOptionInput<TAccountCreator extends string = string, TAccountMarket extends string = string, TAccountOption extends string = string, TAccountSystemProgram extends string = string> = {
1743
- creator: TransactionSigner<TAccountCreator>;
1861
+ }): Promise<AddMarketOptionInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountOption, TAccountSystemProgram>>;
1862
+ type AddMarketOptionInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountOption extends string = string, TAccountSystemProgram extends string = string> = {
1863
+ signer: TransactionSigner<TAccountSigner>;
1744
1864
  market: Address<TAccountMarket>;
1745
1865
  option: Address<TAccountOption>;
1746
1866
  systemProgram?: Address<TAccountSystemProgram>;
1747
1867
  optionId: AddMarketOptionInstructionDataArgs['optionId'];
1748
1868
  };
1749
- 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?: {
1869
+ 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?: {
1750
1870
  programAddress?: TProgramAddress;
1751
- }): AddMarketOptionInstruction<TProgramAddress, TAccountCreator, TAccountMarket, TAccountOption, TAccountSystemProgram>;
1871
+ }): AddMarketOptionInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountOption, TAccountSystemProgram>;
1752
1872
  type ParsedAddMarketOptionInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
1753
1873
  programAddress: Address<TProgram>;
1754
1874
  accounts: {
1755
- creator: TAccountMetas[0];
1875
+ signer: TAccountMetas[0];
1756
1876
  market: TAccountMetas[1];
1757
1877
  option: TAccountMetas[2];
1758
1878
  systemProgram: TAccountMetas[3];
@@ -1800,7 +1920,7 @@ type AddRewardAsyncInput<TAccountSponsor extends string = string, TAccountMarket
1800
1920
  sponsorAccount?: Address<TAccountSponsorAccount>;
1801
1921
  tokenMint: Address<TAccountTokenMint>;
1802
1922
  sponsorTokenAccount: Address<TAccountSponsorTokenAccount>;
1803
- /** Market's ATA holding reward tokens */
1923
+ /** Market-owned ATA holding all program-held tokens for this market. */
1804
1924
  marketTokenAta?: Address<TAccountMarketTokenAta>;
1805
1925
  tokenProgram: Address<TAccountTokenProgram>;
1806
1926
  systemProgram?: Address<TAccountSystemProgram>;
@@ -1816,7 +1936,7 @@ type AddRewardInput<TAccountSponsor extends string = string, TAccountMarket exte
1816
1936
  sponsorAccount: Address<TAccountSponsorAccount>;
1817
1937
  tokenMint: Address<TAccountTokenMint>;
1818
1938
  sponsorTokenAccount: Address<TAccountSponsorTokenAccount>;
1819
- /** Market's ATA holding reward tokens */
1939
+ /** Market-owned ATA holding all program-held tokens for this market. */
1820
1940
  marketTokenAta: Address<TAccountMarketTokenAta>;
1821
1941
  tokenProgram: Address<TAccountTokenProgram>;
1822
1942
  systemProgram?: Address<TAccountSystemProgram>;
@@ -1834,7 +1954,7 @@ type ParsedAddRewardInstruction<TProgram extends string = typeof OPPORTUNITY_MAR
1834
1954
  sponsorAccount: TAccountMetas[2];
1835
1955
  tokenMint: TAccountMetas[3];
1836
1956
  sponsorTokenAccount: TAccountMetas[4];
1837
- /** Market's ATA holding reward tokens */
1957
+ /** Market-owned ATA holding all program-held tokens for this market. */
1838
1958
  marketTokenAta: TAccountMetas[5];
1839
1959
  tokenProgram: TAccountMetas[6];
1840
1960
  systemProgram: TAccountMetas[7];
@@ -1843,6 +1963,68 @@ type ParsedAddRewardInstruction<TProgram extends string = typeof OPPORTUNITY_MAR
1843
1963
  };
1844
1964
  declare function parseAddRewardInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedAddRewardInstruction<TProgram, TAccountMetas>;
1845
1965
 
1966
+ /**
1967
+ * This code was AUTOGENERATED using the Codama library.
1968
+ * Please DO NOT EDIT THIS FILE, instead use visitors
1969
+ * to add features, then rerun Codama to update it.
1970
+ *
1971
+ * @see https://github.com/codama-idl/codama
1972
+ */
1973
+
1974
+ declare const CLAIM_CREATOR_FEES_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
1975
+ declare function getClaimCreatorFeesDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
1976
+ 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<[
1977
+ TAccountSigner extends string ? ReadonlySignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
1978
+ TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
1979
+ TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
1980
+ TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
1981
+ TAccountDestinationTokenAccount extends string ? WritableAccount<TAccountDestinationTokenAccount> : TAccountDestinationTokenAccount,
1982
+ TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
1983
+ ...TRemainingAccounts
1984
+ ]>;
1985
+ type ClaimCreatorFeesInstructionData = {
1986
+ discriminator: ReadonlyUint8Array;
1987
+ };
1988
+ type ClaimCreatorFeesInstructionDataArgs = {};
1989
+ declare function getClaimCreatorFeesInstructionDataEncoder(): FixedSizeEncoder<ClaimCreatorFeesInstructionDataArgs>;
1990
+ declare function getClaimCreatorFeesInstructionDataDecoder(): FixedSizeDecoder<ClaimCreatorFeesInstructionData>;
1991
+ declare function getClaimCreatorFeesInstructionDataCodec(): FixedSizeCodec<ClaimCreatorFeesInstructionDataArgs, ClaimCreatorFeesInstructionData>;
1992
+ 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> = {
1993
+ signer: TransactionSigner<TAccountSigner>;
1994
+ market: Address<TAccountMarket>;
1995
+ tokenMint: Address<TAccountTokenMint>;
1996
+ marketTokenAta?: Address<TAccountMarketTokenAta>;
1997
+ destinationTokenAccount: Address<TAccountDestinationTokenAccount>;
1998
+ tokenProgram: Address<TAccountTokenProgram>;
1999
+ };
2000
+ 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?: {
2001
+ programAddress?: TProgramAddress;
2002
+ }): Promise<ClaimCreatorFeesInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountTokenMint, TAccountMarketTokenAta, TAccountDestinationTokenAccount, TAccountTokenProgram>>;
2003
+ 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> = {
2004
+ signer: TransactionSigner<TAccountSigner>;
2005
+ market: Address<TAccountMarket>;
2006
+ tokenMint: Address<TAccountTokenMint>;
2007
+ marketTokenAta: Address<TAccountMarketTokenAta>;
2008
+ destinationTokenAccount: Address<TAccountDestinationTokenAccount>;
2009
+ tokenProgram: Address<TAccountTokenProgram>;
2010
+ };
2011
+ 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?: {
2012
+ programAddress?: TProgramAddress;
2013
+ }): ClaimCreatorFeesInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountTokenMint, TAccountMarketTokenAta, TAccountDestinationTokenAccount, TAccountTokenProgram>;
2014
+ type ParsedClaimCreatorFeesInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2015
+ programAddress: Address<TProgram>;
2016
+ accounts: {
2017
+ signer: TAccountMetas[0];
2018
+ market: TAccountMetas[1];
2019
+ tokenMint: TAccountMetas[2];
2020
+ marketTokenAta: TAccountMetas[3];
2021
+ destinationTokenAccount: TAccountMetas[4];
2022
+ tokenProgram: TAccountMetas[5];
2023
+ };
2024
+ data: ClaimCreatorFeesInstructionData;
2025
+ };
2026
+ declare function parseClaimCreatorFeesInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedClaimCreatorFeesInstruction<TProgram, TAccountMetas>;
2027
+
1846
2028
  /**
1847
2029
  * This code was AUTOGENERATED using the Codama library.
1848
2030
  * Please DO NOT EDIT THIS FILE, instead use visitors
@@ -1853,13 +2035,13 @@ declare function parseAddRewardInstruction<TProgram extends string, TAccountMeta
1853
2035
 
1854
2036
  declare const CLAIM_FEES_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
1855
2037
  declare function getClaimFeesDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
1856
- 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, TAccountFeeRecipientTokenAccount extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
2038
+ 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<[
1857
2039
  TAccountSigner extends string ? ReadonlySignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
1858
- TAccountCentralState extends string ? ReadonlyAccount<TAccountCentralState> : TAccountCentralState,
2040
+ TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
2041
+ TAccountPlatformConfig extends string ? ReadonlyAccount<TAccountPlatformConfig> : TAccountPlatformConfig,
1859
2042
  TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
1860
- TAccountTokenVault extends string ? WritableAccount<TAccountTokenVault> : TAccountTokenVault,
1861
- TAccountTokenVaultAta extends string ? WritableAccount<TAccountTokenVaultAta> : TAccountTokenVaultAta,
1862
- TAccountFeeRecipientTokenAccount extends string ? WritableAccount<TAccountFeeRecipientTokenAccount> : TAccountFeeRecipientTokenAccount,
2043
+ TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
2044
+ TAccountDestinationTokenAccount extends string ? WritableAccount<TAccountDestinationTokenAccount> : TAccountDestinationTokenAccount,
1863
2045
  TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
1864
2046
  ...TRemainingAccounts
1865
2047
  ]>;
@@ -1870,45 +2052,108 @@ type ClaimFeesInstructionDataArgs = {};
1870
2052
  declare function getClaimFeesInstructionDataEncoder(): FixedSizeEncoder<ClaimFeesInstructionDataArgs>;
1871
2053
  declare function getClaimFeesInstructionDataDecoder(): FixedSizeDecoder<ClaimFeesInstructionData>;
1872
2054
  declare function getClaimFeesInstructionDataCodec(): FixedSizeCodec<ClaimFeesInstructionDataArgs, ClaimFeesInstructionData>;
1873
- type ClaimFeesAsyncInput<TAccountSigner extends string = string, TAccountCentralState extends string = string, TAccountTokenMint extends string = string, TAccountTokenVault extends string = string, TAccountTokenVaultAta extends string = string, TAccountFeeRecipientTokenAccount extends string = string, TAccountTokenProgram extends string = string> = {
2055
+ 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> = {
1874
2056
  signer: TransactionSigner<TAccountSigner>;
1875
- centralState?: Address<TAccountCentralState>;
2057
+ market: Address<TAccountMarket>;
2058
+ platformConfig: Address<TAccountPlatformConfig>;
1876
2059
  tokenMint: Address<TAccountTokenMint>;
1877
- tokenVault?: Address<TAccountTokenVault>;
1878
- tokenVaultAta?: Address<TAccountTokenVaultAta>;
1879
- feeRecipientTokenAccount: Address<TAccountFeeRecipientTokenAccount>;
2060
+ marketTokenAta?: Address<TAccountMarketTokenAta>;
2061
+ destinationTokenAccount: Address<TAccountDestinationTokenAccount>;
1880
2062
  tokenProgram: Address<TAccountTokenProgram>;
1881
2063
  };
1882
- declare function getClaimFeesInstructionAsync<TAccountSigner extends string, TAccountCentralState extends string, TAccountTokenMint extends string, TAccountTokenVault extends string, TAccountTokenVaultAta extends string, TAccountFeeRecipientTokenAccount extends string, TAccountTokenProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ClaimFeesAsyncInput<TAccountSigner, TAccountCentralState, TAccountTokenMint, TAccountTokenVault, TAccountTokenVaultAta, TAccountFeeRecipientTokenAccount, TAccountTokenProgram>, config?: {
2064
+ 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?: {
1883
2065
  programAddress?: TProgramAddress;
1884
- }): Promise<ClaimFeesInstruction<TProgramAddress, TAccountSigner, TAccountCentralState, TAccountTokenMint, TAccountTokenVault, TAccountTokenVaultAta, TAccountFeeRecipientTokenAccount, TAccountTokenProgram>>;
1885
- type ClaimFeesInput<TAccountSigner extends string = string, TAccountCentralState extends string = string, TAccountTokenMint extends string = string, TAccountTokenVault extends string = string, TAccountTokenVaultAta extends string = string, TAccountFeeRecipientTokenAccount extends string = string, TAccountTokenProgram extends string = string> = {
2066
+ }): Promise<ClaimFeesInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountPlatformConfig, TAccountTokenMint, TAccountMarketTokenAta, TAccountDestinationTokenAccount, TAccountTokenProgram>>;
2067
+ 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> = {
1886
2068
  signer: TransactionSigner<TAccountSigner>;
1887
- centralState: Address<TAccountCentralState>;
2069
+ market: Address<TAccountMarket>;
2070
+ platformConfig: Address<TAccountPlatformConfig>;
1888
2071
  tokenMint: Address<TAccountTokenMint>;
1889
- tokenVault: Address<TAccountTokenVault>;
1890
- tokenVaultAta: Address<TAccountTokenVaultAta>;
1891
- feeRecipientTokenAccount: Address<TAccountFeeRecipientTokenAccount>;
2072
+ marketTokenAta: Address<TAccountMarketTokenAta>;
2073
+ destinationTokenAccount: Address<TAccountDestinationTokenAccount>;
1892
2074
  tokenProgram: Address<TAccountTokenProgram>;
1893
2075
  };
1894
- declare function getClaimFeesInstruction<TAccountSigner extends string, TAccountCentralState extends string, TAccountTokenMint extends string, TAccountTokenVault extends string, TAccountTokenVaultAta extends string, TAccountFeeRecipientTokenAccount extends string, TAccountTokenProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ClaimFeesInput<TAccountSigner, TAccountCentralState, TAccountTokenMint, TAccountTokenVault, TAccountTokenVaultAta, TAccountFeeRecipientTokenAccount, TAccountTokenProgram>, config?: {
2076
+ 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?: {
1895
2077
  programAddress?: TProgramAddress;
1896
- }): ClaimFeesInstruction<TProgramAddress, TAccountSigner, TAccountCentralState, TAccountTokenMint, TAccountTokenVault, TAccountTokenVaultAta, TAccountFeeRecipientTokenAccount, TAccountTokenProgram>;
2078
+ }): ClaimFeesInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountPlatformConfig, TAccountTokenMint, TAccountMarketTokenAta, TAccountDestinationTokenAccount, TAccountTokenProgram>;
1897
2079
  type ParsedClaimFeesInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
1898
2080
  programAddress: Address<TProgram>;
1899
2081
  accounts: {
1900
2082
  signer: TAccountMetas[0];
1901
- centralState: TAccountMetas[1];
1902
- tokenMint: TAccountMetas[2];
1903
- tokenVault: TAccountMetas[3];
1904
- tokenVaultAta: TAccountMetas[4];
1905
- feeRecipientTokenAccount: TAccountMetas[5];
2083
+ market: TAccountMetas[1];
2084
+ platformConfig: TAccountMetas[2];
2085
+ tokenMint: TAccountMetas[3];
2086
+ marketTokenAta: TAccountMetas[4];
2087
+ destinationTokenAccount: TAccountMetas[5];
1906
2088
  tokenProgram: TAccountMetas[6];
1907
2089
  };
1908
2090
  data: ClaimFeesInstructionData;
1909
2091
  };
1910
2092
  declare function parseClaimFeesInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedClaimFeesInstruction<TProgram, TAccountMetas>;
1911
2093
 
2094
+ /**
2095
+ * This code was AUTOGENERATED using the Codama library.
2096
+ * Please DO NOT EDIT THIS FILE, instead use visitors
2097
+ * to add features, then rerun Codama to update it.
2098
+ *
2099
+ * @see https://github.com/codama-idl/codama
2100
+ */
2101
+
2102
+ declare const CLOSE_OPTION_ACCOUNT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2103
+ declare function getCloseOptionAccountDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2104
+ 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<[
2105
+ TAccountSigner extends string ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
2106
+ TAccountCreator extends string ? WritableAccount<TAccountCreator> : TAccountCreator,
2107
+ TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
2108
+ TAccountOption extends string ? WritableAccount<TAccountOption> : TAccountOption,
2109
+ TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
2110
+ ...TRemainingAccounts
2111
+ ]>;
2112
+ type CloseOptionAccountInstructionData = {
2113
+ discriminator: ReadonlyUint8Array;
2114
+ optionId: bigint;
2115
+ };
2116
+ type CloseOptionAccountInstructionDataArgs = {
2117
+ optionId: number | bigint;
2118
+ };
2119
+ declare function getCloseOptionAccountInstructionDataEncoder(): FixedSizeEncoder<CloseOptionAccountInstructionDataArgs>;
2120
+ declare function getCloseOptionAccountInstructionDataDecoder(): FixedSizeDecoder<CloseOptionAccountInstructionData>;
2121
+ declare function getCloseOptionAccountInstructionDataCodec(): FixedSizeCodec<CloseOptionAccountInstructionDataArgs, CloseOptionAccountInstructionData>;
2122
+ type CloseOptionAccountAsyncInput<TAccountSigner extends string = string, TAccountCreator extends string = string, TAccountMarket extends string = string, TAccountOption extends string = string, TAccountSystemProgram extends string = string> = {
2123
+ signer: TransactionSigner<TAccountSigner>;
2124
+ creator: Address<TAccountCreator>;
2125
+ market: Address<TAccountMarket>;
2126
+ option?: Address<TAccountOption>;
2127
+ systemProgram?: Address<TAccountSystemProgram>;
2128
+ optionId: CloseOptionAccountInstructionDataArgs['optionId'];
2129
+ };
2130
+ 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?: {
2131
+ programAddress?: TProgramAddress;
2132
+ }): Promise<CloseOptionAccountInstruction<TProgramAddress, TAccountSigner, TAccountCreator, TAccountMarket, TAccountOption, TAccountSystemProgram>>;
2133
+ type CloseOptionAccountInput<TAccountSigner extends string = string, TAccountCreator extends string = string, TAccountMarket extends string = string, TAccountOption extends string = string, TAccountSystemProgram extends string = string> = {
2134
+ signer: TransactionSigner<TAccountSigner>;
2135
+ creator: Address<TAccountCreator>;
2136
+ market: Address<TAccountMarket>;
2137
+ option: Address<TAccountOption>;
2138
+ systemProgram?: Address<TAccountSystemProgram>;
2139
+ optionId: CloseOptionAccountInstructionDataArgs['optionId'];
2140
+ };
2141
+ 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?: {
2142
+ programAddress?: TProgramAddress;
2143
+ }): CloseOptionAccountInstruction<TProgramAddress, TAccountSigner, TAccountCreator, TAccountMarket, TAccountOption, TAccountSystemProgram>;
2144
+ type ParsedCloseOptionAccountInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2145
+ programAddress: Address<TProgram>;
2146
+ accounts: {
2147
+ signer: TAccountMetas[0];
2148
+ creator: TAccountMetas[1];
2149
+ market: TAccountMetas[2];
2150
+ option: TAccountMetas[3];
2151
+ systemProgram: TAccountMetas[4];
2152
+ };
2153
+ data: CloseOptionAccountInstructionData;
2154
+ };
2155
+ declare function parseCloseOptionAccountInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCloseOptionAccountInstruction<TProgram, TAccountMetas>;
2156
+
1912
2157
  /**
1913
2158
  * This code was AUTOGENERATED using the Codama library.
1914
2159
  * Please DO NOT EDIT THIS FILE, instead use visitors
@@ -1923,7 +2168,7 @@ type CloseStakeAccountInstruction<TProgram extends string = typeof OPPORTUNITY_M
1923
2168
  TAccountOwner extends string ? WritableSignerAccount<TAccountOwner> & AccountSignerMeta<TAccountOwner> : TAccountOwner,
1924
2169
  TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
1925
2170
  TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
1926
- TAccountOption extends string ? ReadonlyAccount<TAccountOption> : TAccountOption,
2171
+ TAccountOption extends string ? WritableAccount<TAccountOption> : TAccountOption,
1927
2172
  TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
1928
2173
  TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
1929
2174
  TAccountOwnerTokenAccount extends string ? WritableAccount<TAccountOwnerTokenAccount> : TAccountOwnerTokenAccount,
@@ -1949,7 +2194,7 @@ type CloseStakeAccountAsyncInput<TAccountOwner extends string = string, TAccount
1949
2194
  stakeAccount?: Address<TAccountStakeAccount>;
1950
2195
  option?: Address<TAccountOption>;
1951
2196
  tokenMint: Address<TAccountTokenMint>;
1952
- /** Market's ATA holding reward tokens */
2197
+ /** Market-owned ATA holding all program-held tokens for this market */
1953
2198
  marketTokenAta?: Address<TAccountMarketTokenAta>;
1954
2199
  /** Owner's token account to receive rewards */
1955
2200
  ownerTokenAccount: Address<TAccountOwnerTokenAccount>;
@@ -1967,7 +2212,7 @@ type CloseStakeAccountInput<TAccountOwner extends string = string, TAccountMarke
1967
2212
  stakeAccount: Address<TAccountStakeAccount>;
1968
2213
  option: Address<TAccountOption>;
1969
2214
  tokenMint: Address<TAccountTokenMint>;
1970
- /** Market's ATA holding reward tokens */
2215
+ /** Market-owned ATA holding all program-held tokens for this market */
1971
2216
  marketTokenAta: Address<TAccountMarketTokenAta>;
1972
2217
  /** Owner's token account to receive rewards */
1973
2218
  ownerTokenAccount: Address<TAccountOwnerTokenAccount>;
@@ -1987,7 +2232,7 @@ type ParsedCloseStakeAccountInstruction<TProgram extends string = typeof OPPORTU
1987
2232
  stakeAccount: TAccountMetas[2];
1988
2233
  option: TAccountMetas[3];
1989
2234
  tokenMint: TAccountMetas[4];
1990
- /** Market's ATA holding reward tokens */
2235
+ /** Market-owned ATA holding all program-held tokens for this market */
1991
2236
  marketTokenAta: TAccountMetas[5];
1992
2237
  /** Owner's token account to receive rewards */
1993
2238
  ownerTokenAccount: TAccountMetas[6];
@@ -2008,15 +2253,13 @@ declare function parseCloseStakeAccountInstruction<TProgram extends string, TAcc
2008
2253
 
2009
2254
  declare const CLOSE_STUCK_STAKE_ACCOUNT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2010
2255
  declare function getCloseStuckStakeAccountDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2011
- 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<[
2256
+ 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<[
2012
2257
  TAccountSigner extends string ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
2013
2258
  TAccountMarket extends string ? ReadonlyAccount<TAccountMarket> : TAccountMarket,
2014
2259
  TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
2015
2260
  TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
2016
- TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
2017
2261
  TAccountSignerTokenAccount extends string ? WritableAccount<TAccountSignerTokenAccount> : TAccountSignerTokenAccount,
2018
- TAccountTokenVault extends string ? WritableAccount<TAccountTokenVault> : TAccountTokenVault,
2019
- TAccountTokenVaultAta extends string ? WritableAccount<TAccountTokenVaultAta> : TAccountTokenVaultAta,
2262
+ TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
2020
2263
  TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
2021
2264
  TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
2022
2265
  ...TRemainingAccounts
@@ -2031,44 +2274,36 @@ type CloseStuckStakeAccountInstructionDataArgs = {
2031
2274
  declare function getCloseStuckStakeAccountInstructionDataEncoder(): FixedSizeEncoder<CloseStuckStakeAccountInstructionDataArgs>;
2032
2275
  declare function getCloseStuckStakeAccountInstructionDataDecoder(): FixedSizeDecoder<CloseStuckStakeAccountInstructionData>;
2033
2276
  declare function getCloseStuckStakeAccountInstructionDataCodec(): FixedSizeCodec<CloseStuckStakeAccountInstructionDataArgs, CloseStuckStakeAccountInstructionData>;
2034
- 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> = {
2277
+ 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> = {
2035
2278
  signer: TransactionSigner<TAccountSigner>;
2036
2279
  market: Address<TAccountMarket>;
2037
2280
  stakeAccount?: Address<TAccountStakeAccount>;
2038
2281
  tokenMint: Address<TAccountTokenMint>;
2039
- /** Market's ATA holding staked tokens */
2040
- marketTokenAta?: Address<TAccountMarketTokenAta>;
2041
2282
  /** Signer's token account to receive refund */
2042
2283
  signerTokenAccount: Address<TAccountSignerTokenAccount>;
2043
- tokenVault?: Address<TAccountTokenVault>;
2044
- /** Token vault ATA holding fee tokens */
2045
- tokenVaultAta?: Address<TAccountTokenVaultAta>;
2284
+ marketTokenAta?: Address<TAccountMarketTokenAta>;
2046
2285
  tokenProgram: Address<TAccountTokenProgram>;
2047
2286
  systemProgram?: Address<TAccountSystemProgram>;
2048
2287
  stakeAccountId: CloseStuckStakeAccountInstructionDataArgs['stakeAccountId'];
2049
2288
  };
2050
- 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?: {
2289
+ 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?: {
2051
2290
  programAddress?: TProgramAddress;
2052
- }): Promise<CloseStuckStakeAccountInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountSignerTokenAccount, TAccountTokenVault, TAccountTokenVaultAta, TAccountTokenProgram, TAccountSystemProgram>>;
2053
- 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> = {
2291
+ }): Promise<CloseStuckStakeAccountInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountSignerTokenAccount, TAccountMarketTokenAta, TAccountTokenProgram, TAccountSystemProgram>>;
2292
+ 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> = {
2054
2293
  signer: TransactionSigner<TAccountSigner>;
2055
2294
  market: Address<TAccountMarket>;
2056
2295
  stakeAccount: Address<TAccountStakeAccount>;
2057
2296
  tokenMint: Address<TAccountTokenMint>;
2058
- /** Market's ATA holding staked tokens */
2059
- marketTokenAta: Address<TAccountMarketTokenAta>;
2060
2297
  /** Signer's token account to receive refund */
2061
2298
  signerTokenAccount: Address<TAccountSignerTokenAccount>;
2062
- tokenVault: Address<TAccountTokenVault>;
2063
- /** Token vault ATA holding fee tokens */
2064
- tokenVaultAta: Address<TAccountTokenVaultAta>;
2299
+ marketTokenAta: Address<TAccountMarketTokenAta>;
2065
2300
  tokenProgram: Address<TAccountTokenProgram>;
2066
2301
  systemProgram?: Address<TAccountSystemProgram>;
2067
2302
  stakeAccountId: CloseStuckStakeAccountInstructionDataArgs['stakeAccountId'];
2068
2303
  };
2069
- 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?: {
2304
+ 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?: {
2070
2305
  programAddress?: TProgramAddress;
2071
- }): CloseStuckStakeAccountInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountSignerTokenAccount, TAccountTokenVault, TAccountTokenVaultAta, TAccountTokenProgram, TAccountSystemProgram>;
2306
+ }): CloseStuckStakeAccountInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountSignerTokenAccount, TAccountMarketTokenAta, TAccountTokenProgram, TAccountSystemProgram>;
2072
2307
  type ParsedCloseStuckStakeAccountInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2073
2308
  programAddress: Address<TProgram>;
2074
2309
  accounts: {
@@ -2076,15 +2311,11 @@ type ParsedCloseStuckStakeAccountInstruction<TProgram extends string = typeof OP
2076
2311
  market: TAccountMetas[1];
2077
2312
  stakeAccount: TAccountMetas[2];
2078
2313
  tokenMint: TAccountMetas[3];
2079
- /** Market's ATA holding staked tokens */
2080
- marketTokenAta: TAccountMetas[4];
2081
2314
  /** Signer's token account to receive refund */
2082
- signerTokenAccount: TAccountMetas[5];
2083
- tokenVault: TAccountMetas[6];
2084
- /** Token vault ATA holding fee tokens */
2085
- tokenVaultAta: TAccountMetas[7];
2086
- tokenProgram: TAccountMetas[8];
2087
- systemProgram: TAccountMetas[9];
2315
+ signerTokenAccount: TAccountMetas[4];
2316
+ marketTokenAta: TAccountMetas[5];
2317
+ tokenProgram: TAccountMetas[6];
2318
+ systemProgram: TAccountMetas[7];
2088
2319
  };
2089
2320
  data: CloseStuckStakeAccountInstructionData;
2090
2321
  };
@@ -2100,186 +2331,109 @@ declare function parseCloseStuckStakeAccountInstruction<TProgram extends string,
2100
2331
 
2101
2332
  declare const CREATE_MARKET_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2102
2333
  declare function getCreateMarketDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2103
- 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<[
2334
+ 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<[
2104
2335
  TAccountCreator extends string ? WritableSignerAccount<TAccountCreator> & AccountSignerMeta<TAccountCreator> : TAccountCreator,
2336
+ TAccountPlatformConfig extends string ? ReadonlyAccount<TAccountPlatformConfig> : TAccountPlatformConfig,
2105
2337
  TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
2106
2338
  TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
2107
2339
  TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
2108
- TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
2340
+ TAccountAllowedMint extends string ? ReadonlyAccount<TAccountAllowedMint> : TAccountAllowedMint,
2109
2341
  TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
2110
2342
  TAccountAssociatedTokenProgram extends string ? ReadonlyAccount<TAccountAssociatedTokenProgram> : TAccountAssociatedTokenProgram,
2343
+ TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
2111
2344
  ...TRemainingAccounts
2112
2345
  ]>;
2113
2346
  type CreateMarketInstructionData = {
2114
2347
  discriminator: ReadonlyUint8Array;
2115
2348
  marketIndex: bigint;
2116
- timeToStake: bigint;
2117
- timeToReveal: bigint;
2118
- marketAuthority: Option<Address>;
2119
- unstakeDelaySeconds: bigint;
2349
+ marketAuthority: Address;
2350
+ allowUnstakingEarly: boolean;
2120
2351
  authorizedReaderPubkey: Array<number>;
2121
- allowClosingEarly: boolean;
2122
2352
  revealPeriodAuthority: Address;
2123
2353
  earlinessCutoffSeconds: bigint;
2354
+ earlinessMultiplier: number;
2355
+ minStakeAmount: bigint;
2356
+ creatorFeeClaimer: Address;
2124
2357
  };
2125
2358
  type CreateMarketInstructionDataArgs = {
2126
2359
  marketIndex: number | bigint;
2127
- timeToStake: number | bigint;
2128
- timeToReveal: number | bigint;
2129
- marketAuthority: OptionOrNullable<Address>;
2130
- unstakeDelaySeconds: number | bigint;
2360
+ marketAuthority: Address;
2361
+ allowUnstakingEarly: boolean;
2131
2362
  authorizedReaderPubkey: Array<number>;
2132
- allowClosingEarly: boolean;
2133
2363
  revealPeriodAuthority: Address;
2134
2364
  earlinessCutoffSeconds: number | bigint;
2135
- };
2136
- declare function getCreateMarketInstructionDataEncoder(): Encoder<CreateMarketInstructionDataArgs>;
2137
- declare function getCreateMarketInstructionDataDecoder(): Decoder<CreateMarketInstructionData>;
2138
- declare function getCreateMarketInstructionDataCodec(): Codec<CreateMarketInstructionDataArgs, CreateMarketInstructionData>;
2139
- 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> = {
2365
+ earlinessMultiplier: number;
2366
+ minStakeAmount: number | bigint;
2367
+ creatorFeeClaimer: Address;
2368
+ };
2369
+ declare function getCreateMarketInstructionDataEncoder(): FixedSizeEncoder<CreateMarketInstructionDataArgs>;
2370
+ declare function getCreateMarketInstructionDataDecoder(): FixedSizeDecoder<CreateMarketInstructionData>;
2371
+ declare function getCreateMarketInstructionDataCodec(): FixedSizeCodec<CreateMarketInstructionDataArgs, CreateMarketInstructionData>;
2372
+ 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> = {
2140
2373
  creator: TransactionSigner<TAccountCreator>;
2374
+ platformConfig: Address<TAccountPlatformConfig>;
2141
2375
  tokenMint: Address<TAccountTokenMint>;
2142
2376
  market?: Address<TAccountMarket>;
2143
- /** ATA owned by market PDA, holds reward tokens */
2377
+ /** This ATA holds all of the market's program-held tokens (stakes, rewards, fees). */
2144
2378
  marketTokenAta?: Address<TAccountMarketTokenAta>;
2145
- systemProgram?: Address<TAccountSystemProgram>;
2379
+ allowedMint?: Address<TAccountAllowedMint>;
2146
2380
  tokenProgram: Address<TAccountTokenProgram>;
2147
2381
  associatedTokenProgram?: Address<TAccountAssociatedTokenProgram>;
2382
+ systemProgram?: Address<TAccountSystemProgram>;
2148
2383
  marketIndex: CreateMarketInstructionDataArgs['marketIndex'];
2149
- timeToStake: CreateMarketInstructionDataArgs['timeToStake'];
2150
- timeToReveal: CreateMarketInstructionDataArgs['timeToReveal'];
2151
2384
  marketAuthority: CreateMarketInstructionDataArgs['marketAuthority'];
2152
- unstakeDelaySeconds: CreateMarketInstructionDataArgs['unstakeDelaySeconds'];
2385
+ allowUnstakingEarly: CreateMarketInstructionDataArgs['allowUnstakingEarly'];
2153
2386
  authorizedReaderPubkey: CreateMarketInstructionDataArgs['authorizedReaderPubkey'];
2154
- allowClosingEarly: CreateMarketInstructionDataArgs['allowClosingEarly'];
2155
2387
  revealPeriodAuthority: CreateMarketInstructionDataArgs['revealPeriodAuthority'];
2156
2388
  earlinessCutoffSeconds: CreateMarketInstructionDataArgs['earlinessCutoffSeconds'];
2389
+ earlinessMultiplier: CreateMarketInstructionDataArgs['earlinessMultiplier'];
2390
+ minStakeAmount: CreateMarketInstructionDataArgs['minStakeAmount'];
2391
+ creatorFeeClaimer: CreateMarketInstructionDataArgs['creatorFeeClaimer'];
2157
2392
  };
2158
- 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?: {
2393
+ 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?: {
2159
2394
  programAddress?: TProgramAddress;
2160
- }): Promise<CreateMarketInstruction<TProgramAddress, TAccountCreator, TAccountTokenMint, TAccountMarket, TAccountMarketTokenAta, TAccountSystemProgram, TAccountTokenProgram, TAccountAssociatedTokenProgram>>;
2161
- 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> = {
2395
+ }): Promise<CreateMarketInstruction<TProgramAddress, TAccountCreator, TAccountPlatformConfig, TAccountTokenMint, TAccountMarket, TAccountMarketTokenAta, TAccountAllowedMint, TAccountTokenProgram, TAccountAssociatedTokenProgram, TAccountSystemProgram>>;
2396
+ 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> = {
2162
2397
  creator: TransactionSigner<TAccountCreator>;
2398
+ platformConfig: Address<TAccountPlatformConfig>;
2163
2399
  tokenMint: Address<TAccountTokenMint>;
2164
2400
  market: Address<TAccountMarket>;
2165
- /** ATA owned by market PDA, holds reward tokens */
2401
+ /** This ATA holds all of the market's program-held tokens (stakes, rewards, fees). */
2166
2402
  marketTokenAta: Address<TAccountMarketTokenAta>;
2167
- systemProgram?: Address<TAccountSystemProgram>;
2403
+ allowedMint: Address<TAccountAllowedMint>;
2168
2404
  tokenProgram: Address<TAccountTokenProgram>;
2169
2405
  associatedTokenProgram?: Address<TAccountAssociatedTokenProgram>;
2406
+ systemProgram?: Address<TAccountSystemProgram>;
2170
2407
  marketIndex: CreateMarketInstructionDataArgs['marketIndex'];
2171
- timeToStake: CreateMarketInstructionDataArgs['timeToStake'];
2172
- timeToReveal: CreateMarketInstructionDataArgs['timeToReveal'];
2173
2408
  marketAuthority: CreateMarketInstructionDataArgs['marketAuthority'];
2174
- unstakeDelaySeconds: CreateMarketInstructionDataArgs['unstakeDelaySeconds'];
2409
+ allowUnstakingEarly: CreateMarketInstructionDataArgs['allowUnstakingEarly'];
2175
2410
  authorizedReaderPubkey: CreateMarketInstructionDataArgs['authorizedReaderPubkey'];
2176
- allowClosingEarly: CreateMarketInstructionDataArgs['allowClosingEarly'];
2177
2411
  revealPeriodAuthority: CreateMarketInstructionDataArgs['revealPeriodAuthority'];
2178
2412
  earlinessCutoffSeconds: CreateMarketInstructionDataArgs['earlinessCutoffSeconds'];
2413
+ earlinessMultiplier: CreateMarketInstructionDataArgs['earlinessMultiplier'];
2414
+ minStakeAmount: CreateMarketInstructionDataArgs['minStakeAmount'];
2415
+ creatorFeeClaimer: CreateMarketInstructionDataArgs['creatorFeeClaimer'];
2179
2416
  };
2180
- 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?: {
2417
+ 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?: {
2181
2418
  programAddress?: TProgramAddress;
2182
- }): CreateMarketInstruction<TProgramAddress, TAccountCreator, TAccountTokenMint, TAccountMarket, TAccountMarketTokenAta, TAccountSystemProgram, TAccountTokenProgram, TAccountAssociatedTokenProgram>;
2419
+ }): CreateMarketInstruction<TProgramAddress, TAccountCreator, TAccountPlatformConfig, TAccountTokenMint, TAccountMarket, TAccountMarketTokenAta, TAccountAllowedMint, TAccountTokenProgram, TAccountAssociatedTokenProgram, TAccountSystemProgram>;
2183
2420
  type ParsedCreateMarketInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2184
2421
  programAddress: Address<TProgram>;
2185
2422
  accounts: {
2186
2423
  creator: TAccountMetas[0];
2187
- tokenMint: TAccountMetas[1];
2188
- market: TAccountMetas[2];
2189
- /** ATA owned by market PDA, holds reward tokens */
2190
- marketTokenAta: TAccountMetas[3];
2191
- systemProgram: TAccountMetas[4];
2192
- tokenProgram: TAccountMetas[5];
2193
- associatedTokenProgram: TAccountMetas[6];
2194
- };
2195
- data: CreateMarketInstructionData;
2196
- };
2197
- declare function parseCreateMarketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCreateMarketInstruction<TProgram, TAccountMetas>;
2198
-
2199
- /**
2200
- * This code was AUTOGENERATED using the Codama library.
2201
- * Please DO NOT EDIT THIS FILE, instead use visitors
2202
- * to add features, then rerun Codama to update it.
2203
- *
2204
- * @see https://github.com/codama-idl/codama
2205
- */
2206
-
2207
- declare const DO_UNSTAKE_EARLY_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2208
- declare function getDoUnstakeEarlyDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2209
- 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<[
2210
- TAccountSigner extends string ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
2211
- TAccountMarket extends string ? ReadonlyAccount<TAccountMarket> : TAccountMarket,
2212
- TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
2213
- TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
2214
- TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
2215
- TAccountOwnerTokenAccount extends string ? WritableAccount<TAccountOwnerTokenAccount> : TAccountOwnerTokenAccount,
2216
- TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
2217
- TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
2218
- ...TRemainingAccounts
2219
- ]>;
2220
- type DoUnstakeEarlyInstructionData = {
2221
- discriminator: ReadonlyUint8Array;
2222
- stakeAccountId: number;
2223
- stakeAccountOwner: Address;
2224
- };
2225
- type DoUnstakeEarlyInstructionDataArgs = {
2226
- stakeAccountId: number;
2227
- stakeAccountOwner: Address;
2228
- };
2229
- declare function getDoUnstakeEarlyInstructionDataEncoder(): FixedSizeEncoder<DoUnstakeEarlyInstructionDataArgs>;
2230
- declare function getDoUnstakeEarlyInstructionDataDecoder(): FixedSizeDecoder<DoUnstakeEarlyInstructionData>;
2231
- declare function getDoUnstakeEarlyInstructionDataCodec(): FixedSizeCodec<DoUnstakeEarlyInstructionDataArgs, DoUnstakeEarlyInstructionData>;
2232
- 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> = {
2233
- signer: TransactionSigner<TAccountSigner>;
2234
- market: Address<TAccountMarket>;
2235
- stakeAccount?: Address<TAccountStakeAccount>;
2236
- tokenMint: Address<TAccountTokenMint>;
2237
- /** Market's ATA holding staked tokens */
2238
- marketTokenAta?: Address<TAccountMarketTokenAta>;
2239
- /** Owner's token account to receive refund */
2240
- ownerTokenAccount: Address<TAccountOwnerTokenAccount>;
2241
- tokenProgram: Address<TAccountTokenProgram>;
2242
- systemProgram?: Address<TAccountSystemProgram>;
2243
- stakeAccountId: DoUnstakeEarlyInstructionDataArgs['stakeAccountId'];
2244
- stakeAccountOwner: DoUnstakeEarlyInstructionDataArgs['stakeAccountOwner'];
2245
- };
2246
- 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?: {
2247
- programAddress?: TProgramAddress;
2248
- }): Promise<DoUnstakeEarlyInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountOwnerTokenAccount, TAccountTokenProgram, TAccountSystemProgram>>;
2249
- 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> = {
2250
- signer: TransactionSigner<TAccountSigner>;
2251
- market: Address<TAccountMarket>;
2252
- stakeAccount: Address<TAccountStakeAccount>;
2253
- tokenMint: Address<TAccountTokenMint>;
2254
- /** Market's ATA holding staked tokens */
2255
- marketTokenAta: Address<TAccountMarketTokenAta>;
2256
- /** Owner's token account to receive refund */
2257
- ownerTokenAccount: Address<TAccountOwnerTokenAccount>;
2258
- tokenProgram: Address<TAccountTokenProgram>;
2259
- systemProgram?: Address<TAccountSystemProgram>;
2260
- stakeAccountId: DoUnstakeEarlyInstructionDataArgs['stakeAccountId'];
2261
- stakeAccountOwner: DoUnstakeEarlyInstructionDataArgs['stakeAccountOwner'];
2262
- };
2263
- 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?: {
2264
- programAddress?: TProgramAddress;
2265
- }): DoUnstakeEarlyInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountOwnerTokenAccount, TAccountTokenProgram, TAccountSystemProgram>;
2266
- type ParsedDoUnstakeEarlyInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2267
- programAddress: Address<TProgram>;
2268
- accounts: {
2269
- signer: TAccountMetas[0];
2270
- market: TAccountMetas[1];
2271
- stakeAccount: TAccountMetas[2];
2272
- tokenMint: TAccountMetas[3];
2273
- /** Market's ATA holding staked tokens */
2424
+ platformConfig: TAccountMetas[1];
2425
+ tokenMint: TAccountMetas[2];
2426
+ market: TAccountMetas[3];
2427
+ /** This ATA holds all of the market's program-held tokens (stakes, rewards, fees). */
2274
2428
  marketTokenAta: TAccountMetas[4];
2275
- /** Owner's token account to receive refund */
2276
- ownerTokenAccount: TAccountMetas[5];
2429
+ allowedMint: TAccountMetas[5];
2277
2430
  tokenProgram: TAccountMetas[6];
2278
- systemProgram: TAccountMetas[7];
2431
+ associatedTokenProgram: TAccountMetas[7];
2432
+ systemProgram: TAccountMetas[8];
2279
2433
  };
2280
- data: DoUnstakeEarlyInstructionData;
2434
+ data: CreateMarketInstructionData;
2281
2435
  };
2282
- declare function parseDoUnstakeEarlyInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedDoUnstakeEarlyInstruction<TProgram, TAccountMetas>;
2436
+ declare function parseCreateMarketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCreateMarketInstruction<TProgram, TAccountMetas>;
2283
2437
 
2284
2438
  /**
2285
2439
  * This code was AUTOGENERATED using the Codama library.
@@ -2291,8 +2445,8 @@ declare function parseDoUnstakeEarlyInstruction<TProgram extends string, TAccoun
2291
2445
 
2292
2446
  declare const END_REVEAL_PERIOD_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2293
2447
  declare function getEndRevealPeriodDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2294
- 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<[
2295
- TAccountAuthority extends string ? ReadonlySignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority> : TAccountAuthority,
2448
+ 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<[
2449
+ TAccountSigner extends string ? ReadonlySignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
2296
2450
  TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
2297
2451
  ...TRemainingAccounts
2298
2452
  ]>;
@@ -2303,17 +2457,17 @@ type EndRevealPeriodInstructionDataArgs = {};
2303
2457
  declare function getEndRevealPeriodInstructionDataEncoder(): FixedSizeEncoder<EndRevealPeriodInstructionDataArgs>;
2304
2458
  declare function getEndRevealPeriodInstructionDataDecoder(): FixedSizeDecoder<EndRevealPeriodInstructionData>;
2305
2459
  declare function getEndRevealPeriodInstructionDataCodec(): FixedSizeCodec<EndRevealPeriodInstructionDataArgs, EndRevealPeriodInstructionData>;
2306
- type EndRevealPeriodInput<TAccountAuthority extends string = string, TAccountMarket extends string = string> = {
2307
- authority: TransactionSigner<TAccountAuthority>;
2460
+ type EndRevealPeriodInput<TAccountSigner extends string = string, TAccountMarket extends string = string> = {
2461
+ signer: TransactionSigner<TAccountSigner>;
2308
2462
  market: Address<TAccountMarket>;
2309
2463
  };
2310
- declare function getEndRevealPeriodInstruction<TAccountAuthority extends string, TAccountMarket extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: EndRevealPeriodInput<TAccountAuthority, TAccountMarket>, config?: {
2464
+ declare function getEndRevealPeriodInstruction<TAccountSigner extends string, TAccountMarket extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: EndRevealPeriodInput<TAccountSigner, TAccountMarket>, config?: {
2311
2465
  programAddress?: TProgramAddress;
2312
- }): EndRevealPeriodInstruction<TProgramAddress, TAccountAuthority, TAccountMarket>;
2466
+ }): EndRevealPeriodInstruction<TProgramAddress, TAccountSigner, TAccountMarket>;
2313
2467
  type ParsedEndRevealPeriodInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2314
2468
  programAddress: Address<TProgram>;
2315
2469
  accounts: {
2316
- authority: TAccountMetas[0];
2470
+ signer: TAccountMetas[0];
2317
2471
  market: TAccountMetas[1];
2318
2472
  };
2319
2473
  data: EndRevealPeriodInstructionData;
@@ -2328,56 +2482,56 @@ declare function parseEndRevealPeriodInstruction<TProgram extends string, TAccou
2328
2482
  * @see https://github.com/codama-idl/codama
2329
2483
  */
2330
2484
 
2331
- declare const INCREMENT_OPTION_TALLY_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2332
- declare function getIncrementOptionTallyDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2333
- 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<[
2485
+ declare const FINALIZE_REVEAL_STAKE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2486
+ declare function getFinalizeRevealStakeDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2487
+ 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<[
2334
2488
  TAccountSigner extends string ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
2335
2489
  TAccountOwner extends string ? ReadonlyAccount<TAccountOwner> : TAccountOwner,
2336
- TAccountMarket extends string ? ReadonlyAccount<TAccountMarket> : TAccountMarket,
2490
+ TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
2337
2491
  TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
2338
2492
  TAccountOption extends string ? WritableAccount<TAccountOption> : TAccountOption,
2339
2493
  TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
2340
2494
  ...TRemainingAccounts
2341
2495
  ]>;
2342
- type IncrementOptionTallyInstructionData = {
2496
+ type FinalizeRevealStakeInstructionData = {
2343
2497
  discriminator: ReadonlyUint8Array;
2344
2498
  optionId: bigint;
2345
2499
  stakeAccountId: number;
2346
2500
  };
2347
- type IncrementOptionTallyInstructionDataArgs = {
2501
+ type FinalizeRevealStakeInstructionDataArgs = {
2348
2502
  optionId: number | bigint;
2349
2503
  stakeAccountId: number;
2350
2504
  };
2351
- declare function getIncrementOptionTallyInstructionDataEncoder(): FixedSizeEncoder<IncrementOptionTallyInstructionDataArgs>;
2352
- declare function getIncrementOptionTallyInstructionDataDecoder(): FixedSizeDecoder<IncrementOptionTallyInstructionData>;
2353
- declare function getIncrementOptionTallyInstructionDataCodec(): FixedSizeCodec<IncrementOptionTallyInstructionDataArgs, IncrementOptionTallyInstructionData>;
2354
- 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> = {
2505
+ declare function getFinalizeRevealStakeInstructionDataEncoder(): FixedSizeEncoder<FinalizeRevealStakeInstructionDataArgs>;
2506
+ declare function getFinalizeRevealStakeInstructionDataDecoder(): FixedSizeDecoder<FinalizeRevealStakeInstructionData>;
2507
+ declare function getFinalizeRevealStakeInstructionDataCodec(): FixedSizeCodec<FinalizeRevealStakeInstructionDataArgs, FinalizeRevealStakeInstructionData>;
2508
+ 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> = {
2355
2509
  signer: TransactionSigner<TAccountSigner>;
2356
2510
  owner: Address<TAccountOwner>;
2357
2511
  market: Address<TAccountMarket>;
2358
2512
  stakeAccount?: Address<TAccountStakeAccount>;
2359
2513
  option?: Address<TAccountOption>;
2360
2514
  systemProgram?: Address<TAccountSystemProgram>;
2361
- optionId: IncrementOptionTallyInstructionDataArgs['optionId'];
2362
- stakeAccountId: IncrementOptionTallyInstructionDataArgs['stakeAccountId'];
2515
+ optionId: FinalizeRevealStakeInstructionDataArgs['optionId'];
2516
+ stakeAccountId: FinalizeRevealStakeInstructionDataArgs['stakeAccountId'];
2363
2517
  };
2364
- 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?: {
2518
+ 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?: {
2365
2519
  programAddress?: TProgramAddress;
2366
- }): Promise<IncrementOptionTallyInstruction<TProgramAddress, TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountOption, TAccountSystemProgram>>;
2367
- 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> = {
2520
+ }): Promise<FinalizeRevealStakeInstruction<TProgramAddress, TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountOption, TAccountSystemProgram>>;
2521
+ 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> = {
2368
2522
  signer: TransactionSigner<TAccountSigner>;
2369
2523
  owner: Address<TAccountOwner>;
2370
2524
  market: Address<TAccountMarket>;
2371
2525
  stakeAccount: Address<TAccountStakeAccount>;
2372
2526
  option: Address<TAccountOption>;
2373
2527
  systemProgram?: Address<TAccountSystemProgram>;
2374
- optionId: IncrementOptionTallyInstructionDataArgs['optionId'];
2375
- stakeAccountId: IncrementOptionTallyInstructionDataArgs['stakeAccountId'];
2528
+ optionId: FinalizeRevealStakeInstructionDataArgs['optionId'];
2529
+ stakeAccountId: FinalizeRevealStakeInstructionDataArgs['stakeAccountId'];
2376
2530
  };
2377
- 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?: {
2531
+ 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?: {
2378
2532
  programAddress?: TProgramAddress;
2379
- }): IncrementOptionTallyInstruction<TProgramAddress, TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountOption, TAccountSystemProgram>;
2380
- type ParsedIncrementOptionTallyInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2533
+ }): FinalizeRevealStakeInstruction<TProgramAddress, TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountOption, TAccountSystemProgram>;
2534
+ type ParsedFinalizeRevealStakeInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2381
2535
  programAddress: Address<TProgram>;
2382
2536
  accounts: {
2383
2537
  signer: TAccountMetas[0];
@@ -2387,9 +2541,9 @@ type ParsedIncrementOptionTallyInstruction<TProgram extends string = typeof OPPO
2387
2541
  option: TAccountMetas[4];
2388
2542
  systemProgram: TAccountMetas[5];
2389
2543
  };
2390
- data: IncrementOptionTallyInstructionData;
2544
+ data: FinalizeRevealStakeInstructionData;
2391
2545
  };
2392
- declare function parseIncrementOptionTallyInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedIncrementOptionTallyInstruction<TProgram, TAccountMetas>;
2546
+ declare function parseFinalizeRevealStakeInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedFinalizeRevealStakeInstruction<TProgram, TAccountMetas>;
2393
2547
 
2394
2548
  /**
2395
2549
  * This code was AUTOGENERATED using the Codama library.
@@ -2399,56 +2553,55 @@ declare function parseIncrementOptionTallyInstruction<TProgram extends string, T
2399
2553
  * @see https://github.com/codama-idl/codama
2400
2554
  */
2401
2555
 
2402
- declare const INIT_CENTRAL_STATE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2403
- declare function getInitCentralStateDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2404
- 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<[
2405
- TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer,
2406
- TAccountCentralState extends string ? WritableAccount<TAccountCentralState> : TAccountCentralState,
2556
+ declare const INIT_ALLOWED_MINT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2557
+ declare function getInitAllowedMintDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2558
+ 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<[
2559
+ TAccountUpdateAuthority extends string ? WritableSignerAccount<TAccountUpdateAuthority> & AccountSignerMeta<TAccountUpdateAuthority> : TAccountUpdateAuthority,
2560
+ TAccountPlatformConfig extends string ? ReadonlyAccount<TAccountPlatformConfig> : TAccountPlatformConfig,
2561
+ TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
2562
+ TAccountAllowedMint extends string ? WritableAccount<TAccountAllowedMint> : TAccountAllowedMint,
2407
2563
  TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
2408
2564
  ...TRemainingAccounts
2409
2565
  ]>;
2410
- type InitCentralStateInstructionData = {
2566
+ type InitAllowedMintInstructionData = {
2411
2567
  discriminator: ReadonlyUint8Array;
2412
- protocolFeeBp: number;
2413
- feeRecipient: Address;
2414
- };
2415
- type InitCentralStateInstructionDataArgs = {
2416
- protocolFeeBp: number;
2417
- feeRecipient: Address;
2418
2568
  };
2419
- declare function getInitCentralStateInstructionDataEncoder(): FixedSizeEncoder<InitCentralStateInstructionDataArgs>;
2420
- declare function getInitCentralStateInstructionDataDecoder(): FixedSizeDecoder<InitCentralStateInstructionData>;
2421
- declare function getInitCentralStateInstructionDataCodec(): FixedSizeCodec<InitCentralStateInstructionDataArgs, InitCentralStateInstructionData>;
2422
- type InitCentralStateAsyncInput<TAccountPayer extends string = string, TAccountCentralState extends string = string, TAccountSystemProgram extends string = string> = {
2423
- payer: TransactionSigner<TAccountPayer>;
2424
- centralState?: Address<TAccountCentralState>;
2569
+ type InitAllowedMintInstructionDataArgs = {};
2570
+ declare function getInitAllowedMintInstructionDataEncoder(): FixedSizeEncoder<InitAllowedMintInstructionDataArgs>;
2571
+ declare function getInitAllowedMintInstructionDataDecoder(): FixedSizeDecoder<InitAllowedMintInstructionData>;
2572
+ declare function getInitAllowedMintInstructionDataCodec(): FixedSizeCodec<InitAllowedMintInstructionDataArgs, InitAllowedMintInstructionData>;
2573
+ type InitAllowedMintAsyncInput<TAccountUpdateAuthority extends string = string, TAccountPlatformConfig extends string = string, TAccountTokenMint extends string = string, TAccountAllowedMint extends string = string, TAccountSystemProgram extends string = string> = {
2574
+ updateAuthority: TransactionSigner<TAccountUpdateAuthority>;
2575
+ platformConfig: Address<TAccountPlatformConfig>;
2576
+ tokenMint: Address<TAccountTokenMint>;
2577
+ allowedMint?: Address<TAccountAllowedMint>;
2425
2578
  systemProgram?: Address<TAccountSystemProgram>;
2426
- protocolFeeBp: InitCentralStateInstructionDataArgs['protocolFeeBp'];
2427
- feeRecipient: InitCentralStateInstructionDataArgs['feeRecipient'];
2428
2579
  };
2429
- 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?: {
2580
+ 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?: {
2430
2581
  programAddress?: TProgramAddress;
2431
- }): Promise<InitCentralStateInstruction<TProgramAddress, TAccountPayer, TAccountCentralState, TAccountSystemProgram>>;
2432
- type InitCentralStateInput<TAccountPayer extends string = string, TAccountCentralState extends string = string, TAccountSystemProgram extends string = string> = {
2433
- payer: TransactionSigner<TAccountPayer>;
2434
- centralState: Address<TAccountCentralState>;
2582
+ }): Promise<InitAllowedMintInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountPlatformConfig, TAccountTokenMint, TAccountAllowedMint, TAccountSystemProgram>>;
2583
+ type InitAllowedMintInput<TAccountUpdateAuthority extends string = string, TAccountPlatformConfig extends string = string, TAccountTokenMint extends string = string, TAccountAllowedMint extends string = string, TAccountSystemProgram extends string = string> = {
2584
+ updateAuthority: TransactionSigner<TAccountUpdateAuthority>;
2585
+ platformConfig: Address<TAccountPlatformConfig>;
2586
+ tokenMint: Address<TAccountTokenMint>;
2587
+ allowedMint: Address<TAccountAllowedMint>;
2435
2588
  systemProgram?: Address<TAccountSystemProgram>;
2436
- protocolFeeBp: InitCentralStateInstructionDataArgs['protocolFeeBp'];
2437
- feeRecipient: InitCentralStateInstructionDataArgs['feeRecipient'];
2438
2589
  };
2439
- 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?: {
2590
+ 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?: {
2440
2591
  programAddress?: TProgramAddress;
2441
- }): InitCentralStateInstruction<TProgramAddress, TAccountPayer, TAccountCentralState, TAccountSystemProgram>;
2442
- type ParsedInitCentralStateInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2592
+ }): InitAllowedMintInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountPlatformConfig, TAccountTokenMint, TAccountAllowedMint, TAccountSystemProgram>;
2593
+ type ParsedInitAllowedMintInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2443
2594
  programAddress: Address<TProgram>;
2444
2595
  accounts: {
2445
- payer: TAccountMetas[0];
2446
- centralState: TAccountMetas[1];
2447
- systemProgram: TAccountMetas[2];
2596
+ updateAuthority: TAccountMetas[0];
2597
+ platformConfig: TAccountMetas[1];
2598
+ tokenMint: TAccountMetas[2];
2599
+ allowedMint: TAccountMetas[3];
2600
+ systemProgram: TAccountMetas[4];
2448
2601
  };
2449
- data: InitCentralStateInstructionData;
2602
+ data: InitAllowedMintInstructionData;
2450
2603
  };
2451
- declare function parseInitCentralStateInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedInitCentralStateInstruction<TProgram, TAccountMetas>;
2604
+ declare function parseInitAllowedMintInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedInitAllowedMintInstruction<TProgram, TAccountMetas>;
2452
2605
 
2453
2606
  /**
2454
2607
  * This code was AUTOGENERATED using the Codama library.
@@ -2458,60 +2611,84 @@ declare function parseInitCentralStateInstruction<TProgram extends string, TAcco
2458
2611
  * @see https://github.com/codama-idl/codama
2459
2612
  */
2460
2613
 
2461
- declare const INIT_STAKE_ACCOUNT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2462
- declare function getInitStakeAccountDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2463
- 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<[
2464
- TAccountSigner extends string ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
2465
- TAccountMarket extends string ? ReadonlyAccount<TAccountMarket> : TAccountMarket,
2466
- TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
2614
+ declare const INIT_PLATFORM_CONFIG_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2615
+ declare function getInitPlatformConfigDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2616
+ 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<[
2617
+ TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer,
2618
+ TAccountPlatformConfig extends string ? WritableAccount<TAccountPlatformConfig> : TAccountPlatformConfig,
2467
2619
  TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
2468
2620
  ...TRemainingAccounts
2469
2621
  ]>;
2470
- type InitStakeAccountInstructionData = {
2622
+ type InitPlatformConfigInstructionData = {
2471
2623
  discriminator: ReadonlyUint8Array;
2472
- stateNonce: bigint;
2473
- stakeAccountId: number;
2474
- };
2475
- type InitStakeAccountInstructionDataArgs = {
2476
- stateNonce: number | bigint;
2477
- stakeAccountId: number;
2478
- };
2479
- declare function getInitStakeAccountInstructionDataEncoder(): FixedSizeEncoder<InitStakeAccountInstructionDataArgs>;
2480
- declare function getInitStakeAccountInstructionDataDecoder(): FixedSizeDecoder<InitStakeAccountInstructionData>;
2481
- declare function getInitStakeAccountInstructionDataCodec(): FixedSizeCodec<InitStakeAccountInstructionDataArgs, InitStakeAccountInstructionData>;
2482
- type InitStakeAccountAsyncInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountSystemProgram extends string = string> = {
2483
- signer: TransactionSigner<TAccountSigner>;
2484
- market: Address<TAccountMarket>;
2485
- stakeAccount?: Address<TAccountStakeAccount>;
2486
- systemProgram?: Address<TAccountSystemProgram>;
2487
- stateNonce: InitStakeAccountInstructionDataArgs['stateNonce'];
2488
- stakeAccountId: InitStakeAccountInstructionDataArgs['stakeAccountId'];
2489
- };
2490
- 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?: {
2491
- programAddress?: TProgramAddress;
2492
- }): Promise<InitStakeAccountInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountSystemProgram>>;
2493
- type InitStakeAccountInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountSystemProgram extends string = string> = {
2494
- signer: TransactionSigner<TAccountSigner>;
2495
- market: Address<TAccountMarket>;
2496
- stakeAccount: Address<TAccountStakeAccount>;
2624
+ name: string;
2625
+ platformFeeBp: number;
2626
+ rewardPoolFeeBp: number;
2627
+ creatorFeeBp: number;
2628
+ feeClaimAuthority: Address;
2629
+ minTimeToStakeSeconds: bigint;
2630
+ minRevealPeriodSeconds: bigint;
2631
+ maxRevealPeriodSeconds: bigint;
2632
+ marketResolutionDeadlineSeconds: bigint;
2633
+ };
2634
+ type InitPlatformConfigInstructionDataArgs = {
2635
+ name: string;
2636
+ platformFeeBp: number;
2637
+ rewardPoolFeeBp: number;
2638
+ creatorFeeBp: number;
2639
+ feeClaimAuthority: Address;
2640
+ minTimeToStakeSeconds: number | bigint;
2641
+ minRevealPeriodSeconds: number | bigint;
2642
+ maxRevealPeriodSeconds: number | bigint;
2643
+ marketResolutionDeadlineSeconds: number | bigint;
2644
+ };
2645
+ declare function getInitPlatformConfigInstructionDataEncoder(): Encoder<InitPlatformConfigInstructionDataArgs>;
2646
+ declare function getInitPlatformConfigInstructionDataDecoder(): Decoder<InitPlatformConfigInstructionData>;
2647
+ declare function getInitPlatformConfigInstructionDataCodec(): Codec<InitPlatformConfigInstructionDataArgs, InitPlatformConfigInstructionData>;
2648
+ type InitPlatformConfigAsyncInput<TAccountPayer extends string = string, TAccountPlatformConfig extends string = string, TAccountSystemProgram extends string = string> = {
2649
+ payer: TransactionSigner<TAccountPayer>;
2650
+ platformConfig?: Address<TAccountPlatformConfig>;
2497
2651
  systemProgram?: Address<TAccountSystemProgram>;
2498
- stateNonce: InitStakeAccountInstructionDataArgs['stateNonce'];
2499
- stakeAccountId: InitStakeAccountInstructionDataArgs['stakeAccountId'];
2500
- };
2501
- 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?: {
2652
+ name: InitPlatformConfigInstructionDataArgs['name'];
2653
+ platformFeeBp: InitPlatformConfigInstructionDataArgs['platformFeeBp'];
2654
+ rewardPoolFeeBp: InitPlatformConfigInstructionDataArgs['rewardPoolFeeBp'];
2655
+ creatorFeeBp: InitPlatformConfigInstructionDataArgs['creatorFeeBp'];
2656
+ feeClaimAuthority: InitPlatformConfigInstructionDataArgs['feeClaimAuthority'];
2657
+ minTimeToStakeSeconds: InitPlatformConfigInstructionDataArgs['minTimeToStakeSeconds'];
2658
+ minRevealPeriodSeconds: InitPlatformConfigInstructionDataArgs['minRevealPeriodSeconds'];
2659
+ maxRevealPeriodSeconds: InitPlatformConfigInstructionDataArgs['maxRevealPeriodSeconds'];
2660
+ marketResolutionDeadlineSeconds: InitPlatformConfigInstructionDataArgs['marketResolutionDeadlineSeconds'];
2661
+ };
2662
+ 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?: {
2502
2663
  programAddress?: TProgramAddress;
2503
- }): InitStakeAccountInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount, TAccountSystemProgram>;
2504
- type ParsedInitStakeAccountInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2664
+ }): Promise<InitPlatformConfigInstruction<TProgramAddress, TAccountPayer, TAccountPlatformConfig, TAccountSystemProgram>>;
2665
+ type InitPlatformConfigInput<TAccountPayer extends string = string, TAccountPlatformConfig extends string = string, TAccountSystemProgram extends string = string> = {
2666
+ payer: TransactionSigner<TAccountPayer>;
2667
+ platformConfig: Address<TAccountPlatformConfig>;
2668
+ systemProgram?: Address<TAccountSystemProgram>;
2669
+ name: InitPlatformConfigInstructionDataArgs['name'];
2670
+ platformFeeBp: InitPlatformConfigInstructionDataArgs['platformFeeBp'];
2671
+ rewardPoolFeeBp: InitPlatformConfigInstructionDataArgs['rewardPoolFeeBp'];
2672
+ creatorFeeBp: InitPlatformConfigInstructionDataArgs['creatorFeeBp'];
2673
+ feeClaimAuthority: InitPlatformConfigInstructionDataArgs['feeClaimAuthority'];
2674
+ minTimeToStakeSeconds: InitPlatformConfigInstructionDataArgs['minTimeToStakeSeconds'];
2675
+ minRevealPeriodSeconds: InitPlatformConfigInstructionDataArgs['minRevealPeriodSeconds'];
2676
+ maxRevealPeriodSeconds: InitPlatformConfigInstructionDataArgs['maxRevealPeriodSeconds'];
2677
+ marketResolutionDeadlineSeconds: InitPlatformConfigInstructionDataArgs['marketResolutionDeadlineSeconds'];
2678
+ };
2679
+ 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?: {
2680
+ programAddress?: TProgramAddress;
2681
+ }): InitPlatformConfigInstruction<TProgramAddress, TAccountPayer, TAccountPlatformConfig, TAccountSystemProgram>;
2682
+ type ParsedInitPlatformConfigInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2505
2683
  programAddress: Address<TProgram>;
2506
2684
  accounts: {
2507
- signer: TAccountMetas[0];
2508
- market: TAccountMetas[1];
2509
- stakeAccount: TAccountMetas[2];
2510
- systemProgram: TAccountMetas[3];
2685
+ payer: TAccountMetas[0];
2686
+ platformConfig: TAccountMetas[1];
2687
+ systemProgram: TAccountMetas[2];
2511
2688
  };
2512
- data: InitStakeAccountInstructionData;
2689
+ data: InitPlatformConfigInstructionData;
2513
2690
  };
2514
- declare function parseInitStakeAccountInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedInitStakeAccountInstruction<TProgram, TAccountMetas>;
2691
+ declare function parseInitPlatformConfigInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedInitPlatformConfigInstruction<TProgram, TAccountMetas>;
2515
2692
 
2516
2693
  /**
2517
2694
  * This code was AUTOGENERATED using the Codama library.
@@ -2521,55 +2698,63 @@ declare function parseInitStakeAccountInstruction<TProgram extends string, TAcco
2521
2698
  * @see https://github.com/codama-idl/codama
2522
2699
  */
2523
2700
 
2524
- declare const INIT_TOKEN_VAULT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2525
- declare function getInitTokenVaultDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2526
- 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, TAccountCentralState extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
2701
+ declare const INIT_STAKE_ACCOUNT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2702
+ declare function getInitStakeAccountDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2703
+ 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<[
2527
2704
  TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer,
2528
- TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
2529
- TAccountTokenVault extends string ? WritableAccount<TAccountTokenVault> : TAccountTokenVault,
2530
- TAccountCentralState extends string ? ReadonlyAccount<TAccountCentralState> : TAccountCentralState,
2705
+ TAccountOwner extends string ? ReadonlyAccount<TAccountOwner> : TAccountOwner,
2706
+ TAccountMarket extends string ? ReadonlyAccount<TAccountMarket> : TAccountMarket,
2707
+ TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
2531
2708
  TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
2532
2709
  ...TRemainingAccounts
2533
2710
  ]>;
2534
- type InitTokenVaultInstructionData = {
2711
+ type InitStakeAccountInstructionData = {
2535
2712
  discriminator: ReadonlyUint8Array;
2713
+ stakeAccountId: number;
2714
+ };
2715
+ type InitStakeAccountInstructionDataArgs = {
2716
+ stakeAccountId: number;
2536
2717
  };
2537
- type InitTokenVaultInstructionDataArgs = {};
2538
- declare function getInitTokenVaultInstructionDataEncoder(): FixedSizeEncoder<InitTokenVaultInstructionDataArgs>;
2539
- declare function getInitTokenVaultInstructionDataDecoder(): FixedSizeDecoder<InitTokenVaultInstructionData>;
2540
- declare function getInitTokenVaultInstructionDataCodec(): FixedSizeCodec<InitTokenVaultInstructionDataArgs, InitTokenVaultInstructionData>;
2541
- type InitTokenVaultAsyncInput<TAccountPayer extends string = string, TAccountTokenMint extends string = string, TAccountTokenVault extends string = string, TAccountCentralState extends string = string, TAccountSystemProgram extends string = string> = {
2718
+ declare function getInitStakeAccountInstructionDataEncoder(): FixedSizeEncoder<InitStakeAccountInstructionDataArgs>;
2719
+ declare function getInitStakeAccountInstructionDataDecoder(): FixedSizeDecoder<InitStakeAccountInstructionData>;
2720
+ declare function getInitStakeAccountInstructionDataCodec(): FixedSizeCodec<InitStakeAccountInstructionDataArgs, InitStakeAccountInstructionData>;
2721
+ type InitStakeAccountAsyncInput<TAccountPayer extends string = string, TAccountOwner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountSystemProgram extends string = string> = {
2542
2722
  payer: TransactionSigner<TAccountPayer>;
2543
- tokenMint: Address<TAccountTokenMint>;
2544
- tokenVault?: Address<TAccountTokenVault>;
2545
- centralState?: Address<TAccountCentralState>;
2723
+ /** No signature required: this instruction is permissionless. */
2724
+ owner: Address<TAccountOwner>;
2725
+ market: Address<TAccountMarket>;
2726
+ stakeAccount?: Address<TAccountStakeAccount>;
2546
2727
  systemProgram?: Address<TAccountSystemProgram>;
2728
+ stakeAccountId: InitStakeAccountInstructionDataArgs['stakeAccountId'];
2547
2729
  };
2548
- declare function getInitTokenVaultInstructionAsync<TAccountPayer extends string, TAccountTokenMint extends string, TAccountTokenVault extends string, TAccountCentralState extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: InitTokenVaultAsyncInput<TAccountPayer, TAccountTokenMint, TAccountTokenVault, TAccountCentralState, TAccountSystemProgram>, config?: {
2730
+ 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?: {
2549
2731
  programAddress?: TProgramAddress;
2550
- }): Promise<InitTokenVaultInstruction<TProgramAddress, TAccountPayer, TAccountTokenMint, TAccountTokenVault, TAccountCentralState, TAccountSystemProgram>>;
2551
- type InitTokenVaultInput<TAccountPayer extends string = string, TAccountTokenMint extends string = string, TAccountTokenVault extends string = string, TAccountCentralState extends string = string, TAccountSystemProgram extends string = string> = {
2732
+ }): Promise<InitStakeAccountInstruction<TProgramAddress, TAccountPayer, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountSystemProgram>>;
2733
+ type InitStakeAccountInput<TAccountPayer extends string = string, TAccountOwner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string, TAccountSystemProgram extends string = string> = {
2552
2734
  payer: TransactionSigner<TAccountPayer>;
2553
- tokenMint: Address<TAccountTokenMint>;
2554
- tokenVault: Address<TAccountTokenVault>;
2555
- centralState: Address<TAccountCentralState>;
2735
+ /** No signature required: this instruction is permissionless. */
2736
+ owner: Address<TAccountOwner>;
2737
+ market: Address<TAccountMarket>;
2738
+ stakeAccount: Address<TAccountStakeAccount>;
2556
2739
  systemProgram?: Address<TAccountSystemProgram>;
2740
+ stakeAccountId: InitStakeAccountInstructionDataArgs['stakeAccountId'];
2557
2741
  };
2558
- declare function getInitTokenVaultInstruction<TAccountPayer extends string, TAccountTokenMint extends string, TAccountTokenVault extends string, TAccountCentralState extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: InitTokenVaultInput<TAccountPayer, TAccountTokenMint, TAccountTokenVault, TAccountCentralState, TAccountSystemProgram>, config?: {
2742
+ 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?: {
2559
2743
  programAddress?: TProgramAddress;
2560
- }): InitTokenVaultInstruction<TProgramAddress, TAccountPayer, TAccountTokenMint, TAccountTokenVault, TAccountCentralState, TAccountSystemProgram>;
2561
- type ParsedInitTokenVaultInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2744
+ }): InitStakeAccountInstruction<TProgramAddress, TAccountPayer, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountSystemProgram>;
2745
+ type ParsedInitStakeAccountInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2562
2746
  programAddress: Address<TProgram>;
2563
2747
  accounts: {
2564
2748
  payer: TAccountMetas[0];
2565
- tokenMint: TAccountMetas[1];
2566
- tokenVault: TAccountMetas[2];
2567
- centralState: TAccountMetas[3];
2749
+ /** No signature required: this instruction is permissionless. */
2750
+ owner: TAccountMetas[1];
2751
+ market: TAccountMetas[2];
2752
+ stakeAccount: TAccountMetas[3];
2568
2753
  systemProgram: TAccountMetas[4];
2569
2754
  };
2570
- data: InitTokenVaultInstructionData;
2755
+ data: InitStakeAccountInstructionData;
2571
2756
  };
2572
- declare function parseInitTokenVaultInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedInitTokenVaultInstruction<TProgram, TAccountMetas>;
2757
+ declare function parseInitStakeAccountInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedInitStakeAccountInstruction<TProgram, TAccountMetas>;
2573
2758
 
2574
2759
  /**
2575
2760
  * This code was AUTOGENERATED using the Codama library.
@@ -2581,34 +2766,37 @@ declare function parseInitTokenVaultInstruction<TProgram extends string, TAccoun
2581
2766
 
2582
2767
  declare const OPEN_MARKET_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2583
2768
  declare function getOpenMarketDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2584
- 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<[
2585
- TAccountCreator extends string ? ReadonlySignerAccount<TAccountCreator> & AccountSignerMeta<TAccountCreator> : TAccountCreator,
2769
+ 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<[
2770
+ TAccountMarketAuthority extends string ? ReadonlySignerAccount<TAccountMarketAuthority> & AccountSignerMeta<TAccountMarketAuthority> : TAccountMarketAuthority,
2586
2771
  TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
2772
+ TAccountPlatformConfig extends string ? ReadonlyAccount<TAccountPlatformConfig> : TAccountPlatformConfig,
2587
2773
  ...TRemainingAccounts
2588
2774
  ]>;
2589
2775
  type OpenMarketInstructionData = {
2590
2776
  discriminator: ReadonlyUint8Array;
2591
- openTimestamp: bigint;
2777
+ timeToStake: bigint;
2592
2778
  };
2593
2779
  type OpenMarketInstructionDataArgs = {
2594
- openTimestamp: number | bigint;
2780
+ timeToStake: number | bigint;
2595
2781
  };
2596
2782
  declare function getOpenMarketInstructionDataEncoder(): FixedSizeEncoder<OpenMarketInstructionDataArgs>;
2597
2783
  declare function getOpenMarketInstructionDataDecoder(): FixedSizeDecoder<OpenMarketInstructionData>;
2598
2784
  declare function getOpenMarketInstructionDataCodec(): FixedSizeCodec<OpenMarketInstructionDataArgs, OpenMarketInstructionData>;
2599
- type OpenMarketInput<TAccountCreator extends string = string, TAccountMarket extends string = string> = {
2600
- creator: TransactionSigner<TAccountCreator>;
2785
+ type OpenMarketInput<TAccountMarketAuthority extends string = string, TAccountMarket extends string = string, TAccountPlatformConfig extends string = string> = {
2786
+ marketAuthority: TransactionSigner<TAccountMarketAuthority>;
2601
2787
  market: Address<TAccountMarket>;
2602
- openTimestamp: OpenMarketInstructionDataArgs['openTimestamp'];
2788
+ platformConfig: Address<TAccountPlatformConfig>;
2789
+ timeToStake: OpenMarketInstructionDataArgs['timeToStake'];
2603
2790
  };
2604
- declare function getOpenMarketInstruction<TAccountCreator extends string, TAccountMarket extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: OpenMarketInput<TAccountCreator, TAccountMarket>, config?: {
2791
+ 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?: {
2605
2792
  programAddress?: TProgramAddress;
2606
- }): OpenMarketInstruction<TProgramAddress, TAccountCreator, TAccountMarket>;
2793
+ }): OpenMarketInstruction<TProgramAddress, TAccountMarketAuthority, TAccountMarket, TAccountPlatformConfig>;
2607
2794
  type ParsedOpenMarketInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2608
2795
  programAddress: Address<TProgram>;
2609
2796
  accounts: {
2610
- creator: TAccountMetas[0];
2797
+ marketAuthority: TAccountMetas[0];
2611
2798
  market: TAccountMetas[1];
2799
+ platformConfig: TAccountMetas[2];
2612
2800
  };
2613
2801
  data: OpenMarketInstructionData;
2614
2802
  };
@@ -2622,36 +2810,36 @@ declare function parseOpenMarketInstruction<TProgram extends string, TAccountMet
2622
2810
  * @see https://github.com/codama-idl/codama
2623
2811
  */
2624
2812
 
2625
- declare const PAUSE_MARKET_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2626
- declare function getPauseMarketDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2627
- 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<[
2628
- TAccountAuthority extends string ? ReadonlySignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority> : TAccountAuthority,
2813
+ declare const PAUSE_STAKING_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2814
+ declare function getPauseStakingDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2815
+ 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<[
2816
+ TAccountMarketAuthority extends string ? ReadonlySignerAccount<TAccountMarketAuthority> & AccountSignerMeta<TAccountMarketAuthority> : TAccountMarketAuthority,
2629
2817
  TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
2630
2818
  ...TRemainingAccounts
2631
2819
  ]>;
2632
- type PauseMarketInstructionData = {
2820
+ type PauseStakingInstructionData = {
2633
2821
  discriminator: ReadonlyUint8Array;
2634
2822
  };
2635
- type PauseMarketInstructionDataArgs = {};
2636
- declare function getPauseMarketInstructionDataEncoder(): FixedSizeEncoder<PauseMarketInstructionDataArgs>;
2637
- declare function getPauseMarketInstructionDataDecoder(): FixedSizeDecoder<PauseMarketInstructionData>;
2638
- declare function getPauseMarketInstructionDataCodec(): FixedSizeCodec<PauseMarketInstructionDataArgs, PauseMarketInstructionData>;
2639
- type PauseMarketInput<TAccountAuthority extends string = string, TAccountMarket extends string = string> = {
2640
- authority: TransactionSigner<TAccountAuthority>;
2823
+ type PauseStakingInstructionDataArgs = {};
2824
+ declare function getPauseStakingInstructionDataEncoder(): FixedSizeEncoder<PauseStakingInstructionDataArgs>;
2825
+ declare function getPauseStakingInstructionDataDecoder(): FixedSizeDecoder<PauseStakingInstructionData>;
2826
+ declare function getPauseStakingInstructionDataCodec(): FixedSizeCodec<PauseStakingInstructionDataArgs, PauseStakingInstructionData>;
2827
+ type PauseStakingInput<TAccountMarketAuthority extends string = string, TAccountMarket extends string = string> = {
2828
+ marketAuthority: TransactionSigner<TAccountMarketAuthority>;
2641
2829
  market: Address<TAccountMarket>;
2642
2830
  };
2643
- declare function getPauseMarketInstruction<TAccountAuthority extends string, TAccountMarket extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: PauseMarketInput<TAccountAuthority, TAccountMarket>, config?: {
2831
+ declare function getPauseStakingInstruction<TAccountMarketAuthority extends string, TAccountMarket extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: PauseStakingInput<TAccountMarketAuthority, TAccountMarket>, config?: {
2644
2832
  programAddress?: TProgramAddress;
2645
- }): PauseMarketInstruction<TProgramAddress, TAccountAuthority, TAccountMarket>;
2646
- type ParsedPauseMarketInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2833
+ }): PauseStakingInstruction<TProgramAddress, TAccountMarketAuthority, TAccountMarket>;
2834
+ type ParsedPauseStakingInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2647
2835
  programAddress: Address<TProgram>;
2648
2836
  accounts: {
2649
- authority: TAccountMetas[0];
2837
+ marketAuthority: TAccountMetas[0];
2650
2838
  market: TAccountMetas[1];
2651
2839
  };
2652
- data: PauseMarketInstructionData;
2840
+ data: PauseStakingInstructionData;
2653
2841
  };
2654
- declare function parsePauseMarketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedPauseMarketInstruction<TProgram, TAccountMetas>;
2842
+ declare function parsePauseStakingInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedPauseStakingInstruction<TProgram, TAccountMetas>;
2655
2843
 
2656
2844
  /**
2657
2845
  * This code was AUTOGENERATED using the Codama library.
@@ -2661,82 +2849,36 @@ declare function parsePauseMarketInstruction<TProgram extends string, TAccountMe
2661
2849
  * @see https://github.com/codama-idl/codama
2662
2850
  */
2663
2851
 
2664
- declare const RECLAIM_STAKE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2665
- declare function getReclaimStakeDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2666
- 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<[
2667
- TAccountSigner extends string ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
2668
- TAccountOwner extends string ? ReadonlyAccount<TAccountOwner> : TAccountOwner,
2669
- TAccountMarket extends string ? ReadonlyAccount<TAccountMarket> : TAccountMarket,
2670
- TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
2671
- TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
2672
- TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
2673
- TAccountOwnerTokenAccount extends string ? WritableAccount<TAccountOwnerTokenAccount> : TAccountOwnerTokenAccount,
2674
- TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
2675
- TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
2852
+ declare const RESOLVE_MARKET_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2853
+ declare function getResolveMarketDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2854
+ 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<[
2855
+ TAccountMarketAuthority extends string ? ReadonlySignerAccount<TAccountMarketAuthority> & AccountSignerMeta<TAccountMarketAuthority> : TAccountMarketAuthority,
2856
+ TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
2676
2857
  ...TRemainingAccounts
2677
2858
  ]>;
2678
- type ReclaimStakeInstructionData = {
2859
+ type ResolveMarketInstructionData = {
2679
2860
  discriminator: ReadonlyUint8Array;
2680
- stakeAccountId: number;
2681
- };
2682
- type ReclaimStakeInstructionDataArgs = {
2683
- stakeAccountId: number;
2684
- };
2685
- declare function getReclaimStakeInstructionDataEncoder(): FixedSizeEncoder<ReclaimStakeInstructionDataArgs>;
2686
- declare function getReclaimStakeInstructionDataDecoder(): FixedSizeDecoder<ReclaimStakeInstructionData>;
2687
- declare function getReclaimStakeInstructionDataCodec(): FixedSizeCodec<ReclaimStakeInstructionDataArgs, ReclaimStakeInstructionData>;
2688
- 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> = {
2689
- signer: TransactionSigner<TAccountSigner>;
2690
- owner: Address<TAccountOwner>;
2691
- market: Address<TAccountMarket>;
2692
- stakeAccount?: Address<TAccountStakeAccount>;
2693
- tokenMint: Address<TAccountTokenMint>;
2694
- /** Market's ATA holding staked tokens */
2695
- marketTokenAta?: Address<TAccountMarketTokenAta>;
2696
- /** Owner's token account to receive staked tokens */
2697
- ownerTokenAccount: Address<TAccountOwnerTokenAccount>;
2698
- tokenProgram: Address<TAccountTokenProgram>;
2699
- systemProgram?: Address<TAccountSystemProgram>;
2700
- stakeAccountId: ReclaimStakeInstructionDataArgs['stakeAccountId'];
2701
2861
  };
2702
- 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?: {
2703
- programAddress?: TProgramAddress;
2704
- }): Promise<ReclaimStakeInstruction<TProgramAddress, TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountOwnerTokenAccount, TAccountTokenProgram, TAccountSystemProgram>>;
2705
- 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> = {
2706
- signer: TransactionSigner<TAccountSigner>;
2707
- owner: Address<TAccountOwner>;
2862
+ type ResolveMarketInstructionDataArgs = {};
2863
+ declare function getResolveMarketInstructionDataEncoder(): FixedSizeEncoder<ResolveMarketInstructionDataArgs>;
2864
+ declare function getResolveMarketInstructionDataDecoder(): FixedSizeDecoder<ResolveMarketInstructionData>;
2865
+ declare function getResolveMarketInstructionDataCodec(): FixedSizeCodec<ResolveMarketInstructionDataArgs, ResolveMarketInstructionData>;
2866
+ type ResolveMarketInput<TAccountMarketAuthority extends string = string, TAccountMarket extends string = string> = {
2867
+ marketAuthority: TransactionSigner<TAccountMarketAuthority>;
2708
2868
  market: Address<TAccountMarket>;
2709
- stakeAccount: Address<TAccountStakeAccount>;
2710
- tokenMint: Address<TAccountTokenMint>;
2711
- /** Market's ATA holding staked tokens */
2712
- marketTokenAta: Address<TAccountMarketTokenAta>;
2713
- /** Owner's token account to receive staked tokens */
2714
- ownerTokenAccount: Address<TAccountOwnerTokenAccount>;
2715
- tokenProgram: Address<TAccountTokenProgram>;
2716
- systemProgram?: Address<TAccountSystemProgram>;
2717
- stakeAccountId: ReclaimStakeInstructionDataArgs['stakeAccountId'];
2718
2869
  };
2719
- 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?: {
2870
+ declare function getResolveMarketInstruction<TAccountMarketAuthority extends string, TAccountMarket extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ResolveMarketInput<TAccountMarketAuthority, TAccountMarket>, config?: {
2720
2871
  programAddress?: TProgramAddress;
2721
- }): ReclaimStakeInstruction<TProgramAddress, TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountOwnerTokenAccount, TAccountTokenProgram, TAccountSystemProgram>;
2722
- type ParsedReclaimStakeInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2872
+ }): ResolveMarketInstruction<TProgramAddress, TAccountMarketAuthority, TAccountMarket>;
2873
+ type ParsedResolveMarketInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2723
2874
  programAddress: Address<TProgram>;
2724
2875
  accounts: {
2725
- signer: TAccountMetas[0];
2726
- owner: TAccountMetas[1];
2727
- market: TAccountMetas[2];
2728
- stakeAccount: TAccountMetas[3];
2729
- tokenMint: TAccountMetas[4];
2730
- /** Market's ATA holding staked tokens */
2731
- marketTokenAta: TAccountMetas[5];
2732
- /** Owner's token account to receive staked tokens */
2733
- ownerTokenAccount: TAccountMetas[6];
2734
- tokenProgram: TAccountMetas[7];
2735
- systemProgram: TAccountMetas[8];
2876
+ marketAuthority: TAccountMetas[0];
2877
+ market: TAccountMetas[1];
2736
2878
  };
2737
- data: ReclaimStakeInstructionData;
2879
+ data: ResolveMarketInstructionData;
2738
2880
  };
2739
- declare function parseReclaimStakeInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedReclaimStakeInstruction<TProgram, TAccountMetas>;
2881
+ declare function parseResolveMarketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedResolveMarketInstruction<TProgram, TAccountMetas>;
2740
2882
 
2741
2883
  /**
2742
2884
  * This code was AUTOGENERATED using the Codama library.
@@ -2746,36 +2888,36 @@ declare function parseReclaimStakeInstruction<TProgram extends string, TAccountM
2746
2888
  * @see https://github.com/codama-idl/codama
2747
2889
  */
2748
2890
 
2749
- declare const RESUME_MARKET_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2750
- declare function getResumeMarketDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2751
- 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<[
2752
- TAccountAuthority extends string ? ReadonlySignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority> : TAccountAuthority,
2891
+ declare const RESUME_STAKING_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
2892
+ declare function getResumeStakingDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
2893
+ 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<[
2894
+ TAccountMarketAuthority extends string ? ReadonlySignerAccount<TAccountMarketAuthority> & AccountSignerMeta<TAccountMarketAuthority> : TAccountMarketAuthority,
2753
2895
  TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
2754
2896
  ...TRemainingAccounts
2755
2897
  ]>;
2756
- type ResumeMarketInstructionData = {
2898
+ type ResumeStakingInstructionData = {
2757
2899
  discriminator: ReadonlyUint8Array;
2758
2900
  };
2759
- type ResumeMarketInstructionDataArgs = {};
2760
- declare function getResumeMarketInstructionDataEncoder(): FixedSizeEncoder<ResumeMarketInstructionDataArgs>;
2761
- declare function getResumeMarketInstructionDataDecoder(): FixedSizeDecoder<ResumeMarketInstructionData>;
2762
- declare function getResumeMarketInstructionDataCodec(): FixedSizeCodec<ResumeMarketInstructionDataArgs, ResumeMarketInstructionData>;
2763
- type ResumeMarketInput<TAccountAuthority extends string = string, TAccountMarket extends string = string> = {
2764
- authority: TransactionSigner<TAccountAuthority>;
2901
+ type ResumeStakingInstructionDataArgs = {};
2902
+ declare function getResumeStakingInstructionDataEncoder(): FixedSizeEncoder<ResumeStakingInstructionDataArgs>;
2903
+ declare function getResumeStakingInstructionDataDecoder(): FixedSizeDecoder<ResumeStakingInstructionData>;
2904
+ declare function getResumeStakingInstructionDataCodec(): FixedSizeCodec<ResumeStakingInstructionDataArgs, ResumeStakingInstructionData>;
2905
+ type ResumeStakingInput<TAccountMarketAuthority extends string = string, TAccountMarket extends string = string> = {
2906
+ marketAuthority: TransactionSigner<TAccountMarketAuthority>;
2765
2907
  market: Address<TAccountMarket>;
2766
2908
  };
2767
- declare function getResumeMarketInstruction<TAccountAuthority extends string, TAccountMarket extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ResumeMarketInput<TAccountAuthority, TAccountMarket>, config?: {
2909
+ declare function getResumeStakingInstruction<TAccountMarketAuthority extends string, TAccountMarket extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: ResumeStakingInput<TAccountMarketAuthority, TAccountMarket>, config?: {
2768
2910
  programAddress?: TProgramAddress;
2769
- }): ResumeMarketInstruction<TProgramAddress, TAccountAuthority, TAccountMarket>;
2770
- type ParsedResumeMarketInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2911
+ }): ResumeStakingInstruction<TProgramAddress, TAccountMarketAuthority, TAccountMarket>;
2912
+ type ParsedResumeStakingInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
2771
2913
  programAddress: Address<TProgram>;
2772
2914
  accounts: {
2773
- authority: TAccountMetas[0];
2915
+ marketAuthority: TAccountMetas[0];
2774
2916
  market: TAccountMetas[1];
2775
2917
  };
2776
- data: ResumeMarketInstructionData;
2918
+ data: ResumeStakingInstructionData;
2777
2919
  };
2778
- declare function parseResumeMarketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedResumeMarketInstruction<TProgram, TAccountMetas>;
2920
+ declare function parseResumeStakingInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedResumeStakingInstruction<TProgram, TAccountMetas>;
2779
2921
 
2780
2922
  /**
2781
2923
  * This code was AUTOGENERATED using the Codama library.
@@ -3020,40 +3162,140 @@ declare function parseRevealStakeCompDefInstruction<TProgram extends string, TAc
3020
3162
  * @see https://github.com/codama-idl/codama
3021
3163
  */
3022
3164
 
3023
- declare const SELECT_WINNING_OPTIONS_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
3024
- declare function getSelectWinningOptionsDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
3025
- 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<[
3026
- TAccountAuthority extends string ? ReadonlySignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority> : TAccountAuthority,
3165
+ declare const SET_FEE_CLAIM_AUTHORITY_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
3166
+ declare function getSetFeeClaimAuthorityDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
3167
+ 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<[
3168
+ TAccountUpdateAuthority extends string ? ReadonlySignerAccount<TAccountUpdateAuthority> & AccountSignerMeta<TAccountUpdateAuthority> : TAccountUpdateAuthority,
3169
+ TAccountPlatformConfig extends string ? WritableAccount<TAccountPlatformConfig> : TAccountPlatformConfig,
3170
+ TAccountNewFeeClaimAuthority extends string ? ReadonlyAccount<TAccountNewFeeClaimAuthority> : TAccountNewFeeClaimAuthority,
3171
+ ...TRemainingAccounts
3172
+ ]>;
3173
+ type SetFeeClaimAuthorityInstructionData = {
3174
+ discriminator: ReadonlyUint8Array;
3175
+ };
3176
+ type SetFeeClaimAuthorityInstructionDataArgs = {};
3177
+ declare function getSetFeeClaimAuthorityInstructionDataEncoder(): FixedSizeEncoder<SetFeeClaimAuthorityInstructionDataArgs>;
3178
+ declare function getSetFeeClaimAuthorityInstructionDataDecoder(): FixedSizeDecoder<SetFeeClaimAuthorityInstructionData>;
3179
+ declare function getSetFeeClaimAuthorityInstructionDataCodec(): FixedSizeCodec<SetFeeClaimAuthorityInstructionDataArgs, SetFeeClaimAuthorityInstructionData>;
3180
+ type SetFeeClaimAuthorityInput<TAccountUpdateAuthority extends string = string, TAccountPlatformConfig extends string = string, TAccountNewFeeClaimAuthority extends string = string> = {
3181
+ updateAuthority: TransactionSigner<TAccountUpdateAuthority>;
3182
+ platformConfig: Address<TAccountPlatformConfig>;
3183
+ newFeeClaimAuthority: Address<TAccountNewFeeClaimAuthority>;
3184
+ };
3185
+ 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?: {
3186
+ programAddress?: TProgramAddress;
3187
+ }): SetFeeClaimAuthorityInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountPlatformConfig, TAccountNewFeeClaimAuthority>;
3188
+ type ParsedSetFeeClaimAuthorityInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
3189
+ programAddress: Address<TProgram>;
3190
+ accounts: {
3191
+ updateAuthority: TAccountMetas[0];
3192
+ platformConfig: TAccountMetas[1];
3193
+ newFeeClaimAuthority: TAccountMetas[2];
3194
+ };
3195
+ data: SetFeeClaimAuthorityInstructionData;
3196
+ };
3197
+ declare function parseSetFeeClaimAuthorityInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedSetFeeClaimAuthorityInstruction<TProgram, TAccountMetas>;
3198
+
3199
+ /**
3200
+ * This code was AUTOGENERATED using the Codama library.
3201
+ * Please DO NOT EDIT THIS FILE, instead use visitors
3202
+ * to add features, then rerun Codama to update it.
3203
+ *
3204
+ * @see https://github.com/codama-idl/codama
3205
+ */
3206
+
3207
+ declare const SET_UPDATE_AUTHORITY_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
3208
+ declare function getSetUpdateAuthorityDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
3209
+ 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<[
3210
+ TAccountUpdateAuthority extends string ? ReadonlySignerAccount<TAccountUpdateAuthority> & AccountSignerMeta<TAccountUpdateAuthority> : TAccountUpdateAuthority,
3211
+ TAccountPlatformConfig extends string ? WritableAccount<TAccountPlatformConfig> : TAccountPlatformConfig,
3212
+ TAccountNewAuthority extends string ? ReadonlyAccount<TAccountNewAuthority> : TAccountNewAuthority,
3213
+ ...TRemainingAccounts
3214
+ ]>;
3215
+ type SetUpdateAuthorityInstructionData = {
3216
+ discriminator: ReadonlyUint8Array;
3217
+ };
3218
+ type SetUpdateAuthorityInstructionDataArgs = {};
3219
+ declare function getSetUpdateAuthorityInstructionDataEncoder(): FixedSizeEncoder<SetUpdateAuthorityInstructionDataArgs>;
3220
+ declare function getSetUpdateAuthorityInstructionDataDecoder(): FixedSizeDecoder<SetUpdateAuthorityInstructionData>;
3221
+ declare function getSetUpdateAuthorityInstructionDataCodec(): FixedSizeCodec<SetUpdateAuthorityInstructionDataArgs, SetUpdateAuthorityInstructionData>;
3222
+ type SetUpdateAuthorityInput<TAccountUpdateAuthority extends string = string, TAccountPlatformConfig extends string = string, TAccountNewAuthority extends string = string> = {
3223
+ updateAuthority: TransactionSigner<TAccountUpdateAuthority>;
3224
+ platformConfig: Address<TAccountPlatformConfig>;
3225
+ newAuthority: Address<TAccountNewAuthority>;
3226
+ };
3227
+ 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?: {
3228
+ programAddress?: TProgramAddress;
3229
+ }): SetUpdateAuthorityInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountPlatformConfig, TAccountNewAuthority>;
3230
+ type ParsedSetUpdateAuthorityInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
3231
+ programAddress: Address<TProgram>;
3232
+ accounts: {
3233
+ updateAuthority: TAccountMetas[0];
3234
+ platformConfig: TAccountMetas[1];
3235
+ newAuthority: TAccountMetas[2];
3236
+ };
3237
+ data: SetUpdateAuthorityInstructionData;
3238
+ };
3239
+ declare function parseSetUpdateAuthorityInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedSetUpdateAuthorityInstruction<TProgram, TAccountMetas>;
3240
+
3241
+ /**
3242
+ * This code was AUTOGENERATED using the Codama library.
3243
+ * Please DO NOT EDIT THIS FILE, instead use visitors
3244
+ * to add features, then rerun Codama to update it.
3245
+ *
3246
+ * @see https://github.com/codama-idl/codama
3247
+ */
3248
+
3249
+ declare const SET_WINNING_OPTION_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
3250
+ declare function getSetWinningOptionDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
3251
+ 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<[
3252
+ TAccountMarketAuthority extends string ? ReadonlySignerAccount<TAccountMarketAuthority> & AccountSignerMeta<TAccountMarketAuthority> : TAccountMarketAuthority,
3027
3253
  TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
3254
+ TAccountOption extends string ? WritableAccount<TAccountOption> : TAccountOption,
3028
3255
  ...TRemainingAccounts
3029
3256
  ]>;
3030
- type SelectWinningOptionsInstructionData = {
3257
+ type SetWinningOptionInstructionData = {
3031
3258
  discriminator: ReadonlyUint8Array;
3032
- selections: Array<WinningOption>;
3259
+ optionId: bigint;
3260
+ rewardPercentageBp: number;
3261
+ };
3262
+ type SetWinningOptionInstructionDataArgs = {
3263
+ optionId: number | bigint;
3264
+ rewardPercentageBp: number;
3033
3265
  };
3034
- type SelectWinningOptionsInstructionDataArgs = {
3035
- selections: Array<WinningOptionArgs>;
3266
+ declare function getSetWinningOptionInstructionDataEncoder(): FixedSizeEncoder<SetWinningOptionInstructionDataArgs>;
3267
+ declare function getSetWinningOptionInstructionDataDecoder(): FixedSizeDecoder<SetWinningOptionInstructionData>;
3268
+ declare function getSetWinningOptionInstructionDataCodec(): FixedSizeCodec<SetWinningOptionInstructionDataArgs, SetWinningOptionInstructionData>;
3269
+ type SetWinningOptionAsyncInput<TAccountMarketAuthority extends string = string, TAccountMarket extends string = string, TAccountOption extends string = string> = {
3270
+ marketAuthority: TransactionSigner<TAccountMarketAuthority>;
3271
+ market: Address<TAccountMarket>;
3272
+ option?: Address<TAccountOption>;
3273
+ optionId: SetWinningOptionInstructionDataArgs['optionId'];
3274
+ rewardPercentageBp: SetWinningOptionInstructionDataArgs['rewardPercentageBp'];
3036
3275
  };
3037
- declare function getSelectWinningOptionsInstructionDataEncoder(): Encoder<SelectWinningOptionsInstructionDataArgs>;
3038
- declare function getSelectWinningOptionsInstructionDataDecoder(): Decoder<SelectWinningOptionsInstructionData>;
3039
- declare function getSelectWinningOptionsInstructionDataCodec(): Codec<SelectWinningOptionsInstructionDataArgs, SelectWinningOptionsInstructionData>;
3040
- type SelectWinningOptionsInput<TAccountAuthority extends string = string, TAccountMarket extends string = string> = {
3041
- authority: TransactionSigner<TAccountAuthority>;
3276
+ 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?: {
3277
+ programAddress?: TProgramAddress;
3278
+ }): Promise<SetWinningOptionInstruction<TProgramAddress, TAccountMarketAuthority, TAccountMarket, TAccountOption>>;
3279
+ type SetWinningOptionInput<TAccountMarketAuthority extends string = string, TAccountMarket extends string = string, TAccountOption extends string = string> = {
3280
+ marketAuthority: TransactionSigner<TAccountMarketAuthority>;
3042
3281
  market: Address<TAccountMarket>;
3043
- selections: SelectWinningOptionsInstructionDataArgs['selections'];
3282
+ option: Address<TAccountOption>;
3283
+ optionId: SetWinningOptionInstructionDataArgs['optionId'];
3284
+ rewardPercentageBp: SetWinningOptionInstructionDataArgs['rewardPercentageBp'];
3044
3285
  };
3045
- declare function getSelectWinningOptionsInstruction<TAccountAuthority extends string, TAccountMarket extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: SelectWinningOptionsInput<TAccountAuthority, TAccountMarket>, config?: {
3286
+ 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?: {
3046
3287
  programAddress?: TProgramAddress;
3047
- }): SelectWinningOptionsInstruction<TProgramAddress, TAccountAuthority, TAccountMarket>;
3048
- type ParsedSelectWinningOptionsInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
3288
+ }): SetWinningOptionInstruction<TProgramAddress, TAccountMarketAuthority, TAccountMarket, TAccountOption>;
3289
+ type ParsedSetWinningOptionInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
3049
3290
  programAddress: Address<TProgram>;
3050
3291
  accounts: {
3051
- authority: TAccountMetas[0];
3292
+ marketAuthority: TAccountMetas[0];
3052
3293
  market: TAccountMetas[1];
3294
+ option: TAccountMetas[2];
3053
3295
  };
3054
- data: SelectWinningOptionsInstructionData;
3296
+ data: SetWinningOptionInstructionData;
3055
3297
  };
3056
- declare function parseSelectWinningOptionsInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedSelectWinningOptionsInstruction<TProgram, TAccountMetas>;
3298
+ declare function parseSetWinningOptionInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedSetWinningOptionInstruction<TProgram, TAccountMetas>;
3057
3299
 
3058
3300
  /**
3059
3301
  * This code was AUTOGENERATED using the Codama library.
@@ -3065,16 +3307,14 @@ declare function parseSelectWinningOptionsInstruction<TProgram extends string, T
3065
3307
 
3066
3308
  declare const STAKE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
3067
3309
  declare function getStakeDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
3068
- 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, 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<[
3310
+ 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<[
3069
3311
  TAccountSigner extends string ? ReadonlySignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
3070
3312
  TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer,
3071
- TAccountMarket extends string ? ReadonlyAccount<TAccountMarket> : TAccountMarket,
3313
+ TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
3072
3314
  TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
3073
3315
  TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
3074
3316
  TAccountSignerTokenAccount extends string ? WritableAccount<TAccountSignerTokenAccount> : TAccountSignerTokenAccount,
3075
3317
  TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
3076
- TAccountTokenVault extends string ? WritableAccount<TAccountTokenVault> : TAccountTokenVault,
3077
- TAccountTokenVaultAta extends string ? WritableAccount<TAccountTokenVaultAta> : TAccountTokenVaultAta,
3078
3318
  TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
3079
3319
  TAccountSignPdaAccount extends string ? WritableAccount<TAccountSignPdaAccount> : TAccountSignPdaAccount,
3080
3320
  TAccountMxeAccount extends string ? ReadonlyAccount<TAccountMxeAccount> : TAccountMxeAccount,
@@ -3098,6 +3338,7 @@ type StakeInstructionData = {
3098
3338
  inputNonce: bigint;
3099
3339
  authorizedReaderNonce: bigint;
3100
3340
  userPubkey: Array<number>;
3341
+ stateNonce: bigint;
3101
3342
  };
3102
3343
  type StakeInstructionDataArgs = {
3103
3344
  computationOffset: number | bigint;
@@ -3107,23 +3348,20 @@ type StakeInstructionDataArgs = {
3107
3348
  inputNonce: number | bigint;
3108
3349
  authorizedReaderNonce: number | bigint;
3109
3350
  userPubkey: Array<number>;
3351
+ stateNonce: number | bigint;
3110
3352
  };
3111
3353
  declare function getStakeInstructionDataEncoder(): FixedSizeEncoder<StakeInstructionDataArgs>;
3112
3354
  declare function getStakeInstructionDataDecoder(): FixedSizeDecoder<StakeInstructionData>;
3113
3355
  declare function getStakeInstructionDataCodec(): FixedSizeCodec<StakeInstructionDataArgs, StakeInstructionData>;
3114
- 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, 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> = {
3356
+ 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> = {
3115
3357
  signer: TransactionSigner<TAccountSigner>;
3116
3358
  payer: TransactionSigner<TAccountPayer>;
3117
3359
  market: Address<TAccountMarket>;
3118
- stakeAccount?: Address<TAccountStakeAccount>;
3360
+ stakeAccount: Address<TAccountStakeAccount>;
3119
3361
  tokenMint: Address<TAccountTokenMint>;
3362
+ /** Funds the stake. */
3120
3363
  signerTokenAccount: Address<TAccountSignerTokenAccount>;
3121
- /** Market's ATA for holding staked tokens */
3122
3364
  marketTokenAta?: Address<TAccountMarketTokenAta>;
3123
- /** Token vault for fee collection */
3124
- tokenVault?: Address<TAccountTokenVault>;
3125
- /** Token vault ATA for fee tokens */
3126
- tokenVaultAta?: Address<TAccountTokenVaultAta>;
3127
3365
  tokenProgram: Address<TAccountTokenProgram>;
3128
3366
  signPdaAccount?: Address<TAccountSignPdaAccount>;
3129
3367
  mxeAccount: Address<TAccountMxeAccount>;
@@ -3143,23 +3381,20 @@ type StakeAsyncInput<TAccountSigner extends string = string, TAccountPayer exten
3143
3381
  inputNonce: StakeInstructionDataArgs['inputNonce'];
3144
3382
  authorizedReaderNonce: StakeInstructionDataArgs['authorizedReaderNonce'];
3145
3383
  userPubkey: StakeInstructionDataArgs['userPubkey'];
3384
+ stateNonce: StakeInstructionDataArgs['stateNonce'];
3146
3385
  };
3147
- 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, 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, TAccountTokenProgram, TAccountSignPdaAccount, TAccountMxeAccount, TAccountMempoolAccount, TAccountExecutingPool, TAccountComputationAccount, TAccountCompDefAccount, TAccountClusterAccount, TAccountPoolAccount, TAccountClockAccount, TAccountSystemProgram, TAccountArciumProgram>, config?: {
3386
+ 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?: {
3148
3387
  programAddress?: TProgramAddress;
3149
- }): Promise<StakeInstruction<TProgramAddress, TAccountSigner, TAccountPayer, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountSignerTokenAccount, TAccountMarketTokenAta, TAccountTokenVault, TAccountTokenVaultAta, TAccountTokenProgram, TAccountSignPdaAccount, TAccountMxeAccount, TAccountMempoolAccount, TAccountExecutingPool, TAccountComputationAccount, TAccountCompDefAccount, TAccountClusterAccount, TAccountPoolAccount, TAccountClockAccount, TAccountSystemProgram, TAccountArciumProgram>>;
3150
- 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, 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> = {
3388
+ }): Promise<StakeInstruction<TProgramAddress, TAccountSigner, TAccountPayer, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountSignerTokenAccount, TAccountMarketTokenAta, TAccountTokenProgram, TAccountSignPdaAccount, TAccountMxeAccount, TAccountMempoolAccount, TAccountExecutingPool, TAccountComputationAccount, TAccountCompDefAccount, TAccountClusterAccount, TAccountPoolAccount, TAccountClockAccount, TAccountSystemProgram, TAccountArciumProgram>>;
3389
+ 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> = {
3151
3390
  signer: TransactionSigner<TAccountSigner>;
3152
3391
  payer: TransactionSigner<TAccountPayer>;
3153
3392
  market: Address<TAccountMarket>;
3154
3393
  stakeAccount: Address<TAccountStakeAccount>;
3155
3394
  tokenMint: Address<TAccountTokenMint>;
3395
+ /** Funds the stake. */
3156
3396
  signerTokenAccount: Address<TAccountSignerTokenAccount>;
3157
- /** Market's ATA for holding staked tokens */
3158
3397
  marketTokenAta: Address<TAccountMarketTokenAta>;
3159
- /** Token vault for fee collection */
3160
- tokenVault: Address<TAccountTokenVault>;
3161
- /** Token vault ATA for fee tokens */
3162
- tokenVaultAta: Address<TAccountTokenVaultAta>;
3163
3398
  tokenProgram: Address<TAccountTokenProgram>;
3164
3399
  signPdaAccount: Address<TAccountSignPdaAccount>;
3165
3400
  mxeAccount: Address<TAccountMxeAccount>;
@@ -3179,10 +3414,11 @@ type StakeInput<TAccountSigner extends string = string, TAccountPayer extends st
3179
3414
  inputNonce: StakeInstructionDataArgs['inputNonce'];
3180
3415
  authorizedReaderNonce: StakeInstructionDataArgs['authorizedReaderNonce'];
3181
3416
  userPubkey: StakeInstructionDataArgs['userPubkey'];
3417
+ stateNonce: StakeInstructionDataArgs['stateNonce'];
3182
3418
  };
3183
- 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, 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, TAccountTokenProgram, TAccountSignPdaAccount, TAccountMxeAccount, TAccountMempoolAccount, TAccountExecutingPool, TAccountComputationAccount, TAccountCompDefAccount, TAccountClusterAccount, TAccountPoolAccount, TAccountClockAccount, TAccountSystemProgram, TAccountArciumProgram>, config?: {
3419
+ 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?: {
3184
3420
  programAddress?: TProgramAddress;
3185
- }): StakeInstruction<TProgramAddress, TAccountSigner, TAccountPayer, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountSignerTokenAccount, TAccountMarketTokenAta, TAccountTokenVault, TAccountTokenVaultAta, TAccountTokenProgram, TAccountSignPdaAccount, TAccountMxeAccount, TAccountMempoolAccount, TAccountExecutingPool, TAccountComputationAccount, TAccountCompDefAccount, TAccountClusterAccount, TAccountPoolAccount, TAccountClockAccount, TAccountSystemProgram, TAccountArciumProgram>;
3421
+ }): StakeInstruction<TProgramAddress, TAccountSigner, TAccountPayer, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountSignerTokenAccount, TAccountMarketTokenAta, TAccountTokenProgram, TAccountSignPdaAccount, TAccountMxeAccount, TAccountMempoolAccount, TAccountExecutingPool, TAccountComputationAccount, TAccountCompDefAccount, TAccountClusterAccount, TAccountPoolAccount, TAccountClockAccount, TAccountSystemProgram, TAccountArciumProgram>;
3186
3422
  type ParsedStakeInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
3187
3423
  programAddress: Address<TProgram>;
3188
3424
  accounts: {
@@ -3191,25 +3427,21 @@ type ParsedStakeInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_
3191
3427
  market: TAccountMetas[2];
3192
3428
  stakeAccount: TAccountMetas[3];
3193
3429
  tokenMint: TAccountMetas[4];
3430
+ /** Funds the stake. */
3194
3431
  signerTokenAccount: TAccountMetas[5];
3195
- /** Market's ATA for holding staked tokens */
3196
3432
  marketTokenAta: TAccountMetas[6];
3197
- /** Token vault for fee collection */
3198
- tokenVault: TAccountMetas[7];
3199
- /** Token vault ATA for fee tokens */
3200
- tokenVaultAta: TAccountMetas[8];
3201
- tokenProgram: TAccountMetas[9];
3202
- signPdaAccount: TAccountMetas[10];
3203
- mxeAccount: TAccountMetas[11];
3204
- mempoolAccount: TAccountMetas[12];
3205
- executingPool: TAccountMetas[13];
3206
- computationAccount: TAccountMetas[14];
3207
- compDefAccount: TAccountMetas[15];
3208
- clusterAccount: TAccountMetas[16];
3209
- poolAccount: TAccountMetas[17];
3210
- clockAccount: TAccountMetas[18];
3211
- systemProgram: TAccountMetas[19];
3212
- arciumProgram: TAccountMetas[20];
3433
+ tokenProgram: TAccountMetas[7];
3434
+ signPdaAccount: TAccountMetas[8];
3435
+ mxeAccount: TAccountMetas[9];
3436
+ mempoolAccount: TAccountMetas[10];
3437
+ executingPool: TAccountMetas[11];
3438
+ computationAccount: TAccountMetas[12];
3439
+ compDefAccount: TAccountMetas[13];
3440
+ clusterAccount: TAccountMetas[14];
3441
+ poolAccount: TAccountMetas[15];
3442
+ clockAccount: TAccountMetas[16];
3443
+ systemProgram: TAccountMetas[17];
3444
+ arciumProgram: TAccountMetas[18];
3213
3445
  };
3214
3446
  data: StakeInstructionData;
3215
3447
  };
@@ -3225,16 +3457,15 @@ declare function parseStakeInstruction<TProgram extends string, TAccountMetas ex
3225
3457
 
3226
3458
  declare const STAKE_CALLBACK_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
3227
3459
  declare function getStakeCallbackDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
3228
- 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<[
3460
+ 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<[
3229
3461
  TAccountArciumProgram extends string ? ReadonlyAccount<TAccountArciumProgram> : TAccountArciumProgram,
3230
3462
  TAccountCompDefAccount extends string ? ReadonlyAccount<TAccountCompDefAccount> : TAccountCompDefAccount,
3231
3463
  TAccountMxeAccount extends string ? ReadonlyAccount<TAccountMxeAccount> : TAccountMxeAccount,
3232
3464
  TAccountComputationAccount extends string ? ReadonlyAccount<TAccountComputationAccount> : TAccountComputationAccount,
3233
3465
  TAccountClusterAccount extends string ? ReadonlyAccount<TAccountClusterAccount> : TAccountClusterAccount,
3234
3466
  TAccountInstructionsSysvar extends string ? ReadonlyAccount<TAccountInstructionsSysvar> : TAccountInstructionsSysvar,
3235
- TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
3236
3467
  TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
3237
- TAccountTokenVault extends string ? WritableAccount<TAccountTokenVault> : TAccountTokenVault,
3468
+ TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
3238
3469
  ...TRemainingAccounts
3239
3470
  ]>;
3240
3471
  type StakeCallbackInstructionData = {
@@ -3263,21 +3494,20 @@ type StakeCallbackInstructionDataArgs = {
3263
3494
  declare function getStakeCallbackInstructionDataEncoder(): Encoder<StakeCallbackInstructionDataArgs>;
3264
3495
  declare function getStakeCallbackInstructionDataDecoder(): Decoder<StakeCallbackInstructionData>;
3265
3496
  declare function getStakeCallbackInstructionDataCodec(): Codec<StakeCallbackInstructionDataArgs, StakeCallbackInstructionData>;
3266
- 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> = {
3497
+ 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> = {
3267
3498
  arciumProgram?: Address<TAccountArciumProgram>;
3268
3499
  compDefAccount: Address<TAccountCompDefAccount>;
3269
3500
  mxeAccount: Address<TAccountMxeAccount>;
3270
3501
  computationAccount: Address<TAccountComputationAccount>;
3271
3502
  clusterAccount: Address<TAccountClusterAccount>;
3272
3503
  instructionsSysvar?: Address<TAccountInstructionsSysvar>;
3273
- market: Address<TAccountMarket>;
3274
3504
  stakeAccount: Address<TAccountStakeAccount>;
3275
- tokenVault: Address<TAccountTokenVault>;
3505
+ market: Address<TAccountMarket>;
3276
3506
  output: StakeCallbackInstructionDataArgs['output'];
3277
3507
  };
3278
- 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?: {
3508
+ 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?: {
3279
3509
  programAddress?: TProgramAddress;
3280
- }): StakeCallbackInstruction<TProgramAddress, TAccountArciumProgram, TAccountCompDefAccount, TAccountMxeAccount, TAccountComputationAccount, TAccountClusterAccount, TAccountInstructionsSysvar, TAccountMarket, TAccountStakeAccount, TAccountTokenVault>;
3510
+ }): StakeCallbackInstruction<TProgramAddress, TAccountArciumProgram, TAccountCompDefAccount, TAccountMxeAccount, TAccountComputationAccount, TAccountClusterAccount, TAccountInstructionsSysvar, TAccountStakeAccount, TAccountMarket>;
3281
3511
  type ParsedStakeCallbackInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
3282
3512
  programAddress: Address<TProgram>;
3283
3513
  accounts: {
@@ -3287,9 +3517,8 @@ type ParsedStakeCallbackInstruction<TProgram extends string = typeof OPPORTUNITY
3287
3517
  computationAccount: TAccountMetas[3];
3288
3518
  clusterAccount: TAccountMetas[4];
3289
3519
  instructionsSysvar: TAccountMetas[5];
3290
- market: TAccountMetas[6];
3291
- stakeAccount: TAccountMetas[7];
3292
- tokenVault: TAccountMetas[8];
3520
+ stakeAccount: TAccountMetas[6];
3521
+ market: TAccountMetas[7];
3293
3522
  };
3294
3523
  data: StakeCallbackInstructionData;
3295
3524
  };
@@ -3357,103 +3586,79 @@ declare function parseStakeCompDefInstruction<TProgram extends string, TAccountM
3357
3586
  * @see https://github.com/codama-idl/codama
3358
3587
  */
3359
3588
 
3360
- declare const TRANSFER_CENTRAL_STATE_AUTHORITY_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
3361
- declare function getTransferCentralStateAuthorityDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
3362
- type TransferCentralStateAuthorityInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountAuthority extends string | AccountMeta<string> = string, TAccountCentralState extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
3363
- TAccountAuthority extends string ? ReadonlySignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority> : TAccountAuthority,
3364
- TAccountCentralState extends string ? WritableAccount<TAccountCentralState> : TAccountCentralState,
3365
- ...TRemainingAccounts
3366
- ]>;
3367
- type TransferCentralStateAuthorityInstructionData = {
3368
- discriminator: ReadonlyUint8Array;
3369
- newAuthority: Address;
3370
- };
3371
- type TransferCentralStateAuthorityInstructionDataArgs = {
3372
- newAuthority: Address;
3373
- };
3374
- declare function getTransferCentralStateAuthorityInstructionDataEncoder(): FixedSizeEncoder<TransferCentralStateAuthorityInstructionDataArgs>;
3375
- declare function getTransferCentralStateAuthorityInstructionDataDecoder(): FixedSizeDecoder<TransferCentralStateAuthorityInstructionData>;
3376
- declare function getTransferCentralStateAuthorityInstructionDataCodec(): FixedSizeCodec<TransferCentralStateAuthorityInstructionDataArgs, TransferCentralStateAuthorityInstructionData>;
3377
- type TransferCentralStateAuthorityAsyncInput<TAccountAuthority extends string = string, TAccountCentralState extends string = string> = {
3378
- authority: TransactionSigner<TAccountAuthority>;
3379
- centralState?: Address<TAccountCentralState>;
3380
- newAuthority: TransferCentralStateAuthorityInstructionDataArgs['newAuthority'];
3381
- };
3382
- declare function getTransferCentralStateAuthorityInstructionAsync<TAccountAuthority extends string, TAccountCentralState extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: TransferCentralStateAuthorityAsyncInput<TAccountAuthority, TAccountCentralState>, config?: {
3383
- programAddress?: TProgramAddress;
3384
- }): Promise<TransferCentralStateAuthorityInstruction<TProgramAddress, TAccountAuthority, TAccountCentralState>>;
3385
- type TransferCentralStateAuthorityInput<TAccountAuthority extends string = string, TAccountCentralState extends string = string> = {
3386
- authority: TransactionSigner<TAccountAuthority>;
3387
- centralState: Address<TAccountCentralState>;
3388
- newAuthority: TransferCentralStateAuthorityInstructionDataArgs['newAuthority'];
3389
- };
3390
- declare function getTransferCentralStateAuthorityInstruction<TAccountAuthority extends string, TAccountCentralState extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: TransferCentralStateAuthorityInput<TAccountAuthority, TAccountCentralState>, config?: {
3391
- programAddress?: TProgramAddress;
3392
- }): TransferCentralStateAuthorityInstruction<TProgramAddress, TAccountAuthority, TAccountCentralState>;
3393
- type ParsedTransferCentralStateAuthorityInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
3394
- programAddress: Address<TProgram>;
3395
- accounts: {
3396
- authority: TAccountMetas[0];
3397
- centralState: TAccountMetas[1];
3398
- };
3399
- data: TransferCentralStateAuthorityInstructionData;
3400
- };
3401
- declare function parseTransferCentralStateAuthorityInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedTransferCentralStateAuthorityInstruction<TProgram, TAccountMetas>;
3402
-
3403
- /**
3404
- * This code was AUTOGENERATED using the Codama library.
3405
- * Please DO NOT EDIT THIS FILE, instead use visitors
3406
- * to add features, then rerun Codama to update it.
3407
- *
3408
- * @see https://github.com/codama-idl/codama
3409
- */
3410
-
3411
- declare const UNSTAKE_EARLY_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
3412
- declare function getUnstakeEarlyDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
3413
- 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<[
3589
+ declare const UNSTAKE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
3590
+ declare function getUnstakeDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
3591
+ 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<[
3414
3592
  TAccountSigner extends string ? WritableSignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner,
3593
+ TAccountOwner extends string ? ReadonlyAccount<TAccountOwner> : TAccountOwner,
3415
3594
  TAccountMarket extends string ? ReadonlyAccount<TAccountMarket> : TAccountMarket,
3416
3595
  TAccountStakeAccount extends string ? WritableAccount<TAccountStakeAccount> : TAccountStakeAccount,
3596
+ TAccountTokenMint extends string ? ReadonlyAccount<TAccountTokenMint> : TAccountTokenMint,
3597
+ TAccountMarketTokenAta extends string ? WritableAccount<TAccountMarketTokenAta> : TAccountMarketTokenAta,
3598
+ TAccountOwnerTokenAccount extends string ? WritableAccount<TAccountOwnerTokenAccount> : TAccountOwnerTokenAccount,
3599
+ TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
3600
+ TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
3417
3601
  ...TRemainingAccounts
3418
3602
  ]>;
3419
- type UnstakeEarlyInstructionData = {
3603
+ type UnstakeInstructionData = {
3420
3604
  discriminator: ReadonlyUint8Array;
3421
3605
  stakeAccountId: number;
3422
3606
  };
3423
- type UnstakeEarlyInstructionDataArgs = {
3607
+ type UnstakeInstructionDataArgs = {
3424
3608
  stakeAccountId: number;
3425
3609
  };
3426
- declare function getUnstakeEarlyInstructionDataEncoder(): FixedSizeEncoder<UnstakeEarlyInstructionDataArgs>;
3427
- declare function getUnstakeEarlyInstructionDataDecoder(): FixedSizeDecoder<UnstakeEarlyInstructionData>;
3428
- declare function getUnstakeEarlyInstructionDataCodec(): FixedSizeCodec<UnstakeEarlyInstructionDataArgs, UnstakeEarlyInstructionData>;
3429
- type UnstakeEarlyAsyncInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string> = {
3610
+ declare function getUnstakeInstructionDataEncoder(): FixedSizeEncoder<UnstakeInstructionDataArgs>;
3611
+ declare function getUnstakeInstructionDataDecoder(): FixedSizeDecoder<UnstakeInstructionData>;
3612
+ declare function getUnstakeInstructionDataCodec(): FixedSizeCodec<UnstakeInstructionDataArgs, UnstakeInstructionData>;
3613
+ 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> = {
3430
3614
  signer: TransactionSigner<TAccountSigner>;
3615
+ owner: Address<TAccountOwner>;
3431
3616
  market: Address<TAccountMarket>;
3432
3617
  stakeAccount?: Address<TAccountStakeAccount>;
3433
- stakeAccountId: UnstakeEarlyInstructionDataArgs['stakeAccountId'];
3618
+ tokenMint: Address<TAccountTokenMint>;
3619
+ marketTokenAta?: Address<TAccountMarketTokenAta>;
3620
+ /** Owner's token account to receive staked tokens */
3621
+ ownerTokenAccount: Address<TAccountOwnerTokenAccount>;
3622
+ tokenProgram: Address<TAccountTokenProgram>;
3623
+ systemProgram?: Address<TAccountSystemProgram>;
3624
+ stakeAccountId: UnstakeInstructionDataArgs['stakeAccountId'];
3434
3625
  };
3435
- 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?: {
3626
+ 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?: {
3436
3627
  programAddress?: TProgramAddress;
3437
- }): Promise<UnstakeEarlyInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount>>;
3438
- type UnstakeEarlyInput<TAccountSigner extends string = string, TAccountMarket extends string = string, TAccountStakeAccount extends string = string> = {
3628
+ }): Promise<UnstakeInstruction<TProgramAddress, TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountOwnerTokenAccount, TAccountTokenProgram, TAccountSystemProgram>>;
3629
+ 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> = {
3439
3630
  signer: TransactionSigner<TAccountSigner>;
3631
+ owner: Address<TAccountOwner>;
3440
3632
  market: Address<TAccountMarket>;
3441
3633
  stakeAccount: Address<TAccountStakeAccount>;
3442
- stakeAccountId: UnstakeEarlyInstructionDataArgs['stakeAccountId'];
3634
+ tokenMint: Address<TAccountTokenMint>;
3635
+ marketTokenAta: Address<TAccountMarketTokenAta>;
3636
+ /** Owner's token account to receive staked tokens */
3637
+ ownerTokenAccount: Address<TAccountOwnerTokenAccount>;
3638
+ tokenProgram: Address<TAccountTokenProgram>;
3639
+ systemProgram?: Address<TAccountSystemProgram>;
3640
+ stakeAccountId: UnstakeInstructionDataArgs['stakeAccountId'];
3443
3641
  };
3444
- 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?: {
3642
+ 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?: {
3445
3643
  programAddress?: TProgramAddress;
3446
- }): UnstakeEarlyInstruction<TProgramAddress, TAccountSigner, TAccountMarket, TAccountStakeAccount>;
3447
- type ParsedUnstakeEarlyInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
3644
+ }): UnstakeInstruction<TProgramAddress, TAccountSigner, TAccountOwner, TAccountMarket, TAccountStakeAccount, TAccountTokenMint, TAccountMarketTokenAta, TAccountOwnerTokenAccount, TAccountTokenProgram, TAccountSystemProgram>;
3645
+ type ParsedUnstakeInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
3448
3646
  programAddress: Address<TProgram>;
3449
3647
  accounts: {
3450
3648
  signer: TAccountMetas[0];
3451
- market: TAccountMetas[1];
3452
- stakeAccount: TAccountMetas[2];
3649
+ owner: TAccountMetas[1];
3650
+ market: TAccountMetas[2];
3651
+ stakeAccount: TAccountMetas[3];
3652
+ tokenMint: TAccountMetas[4];
3653
+ marketTokenAta: TAccountMetas[5];
3654
+ /** Owner's token account to receive staked tokens */
3655
+ ownerTokenAccount: TAccountMetas[6];
3656
+ tokenProgram: TAccountMetas[7];
3657
+ systemProgram: TAccountMetas[8];
3453
3658
  };
3454
- data: UnstakeEarlyInstructionData;
3659
+ data: UnstakeInstructionData;
3455
3660
  };
3456
- declare function parseUnstakeEarlyInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedUnstakeEarlyInstruction<TProgram, TAccountMetas>;
3661
+ declare function parseUnstakeInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedUnstakeInstruction<TProgram, TAccountMetas>;
3457
3662
 
3458
3663
  /**
3459
3664
  * This code was AUTOGENERATED using the Codama library.
@@ -3463,52 +3668,58 @@ declare function parseUnstakeEarlyInstruction<TProgram extends string, TAccountM
3463
3668
  * @see https://github.com/codama-idl/codama
3464
3669
  */
3465
3670
 
3466
- declare const UPDATE_CENTRAL_STATE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
3467
- declare function getUpdateCentralStateDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
3468
- type UpdateCentralStateInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountAuthority extends string | AccountMeta<string> = string, TAccountCentralState extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
3469
- TAccountAuthority extends string ? ReadonlySignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority> : TAccountAuthority,
3470
- TAccountCentralState extends string ? WritableAccount<TAccountCentralState> : TAccountCentralState,
3671
+ declare const UPDATE_PLATFORM_CONFIG_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
3672
+ declare function getUpdatePlatformConfigDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
3673
+ 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<[
3674
+ TAccountUpdateAuthority extends string ? ReadonlySignerAccount<TAccountUpdateAuthority> & AccountSignerMeta<TAccountUpdateAuthority> : TAccountUpdateAuthority,
3675
+ TAccountPlatformConfig extends string ? WritableAccount<TAccountPlatformConfig> : TAccountPlatformConfig,
3471
3676
  ...TRemainingAccounts
3472
3677
  ]>;
3473
- type UpdateCentralStateInstructionData = {
3678
+ type UpdatePlatformConfigInstructionData = {
3474
3679
  discriminator: ReadonlyUint8Array;
3475
- protocolFeeBp: number;
3476
- feeRecipient: Address;
3477
- };
3478
- type UpdateCentralStateInstructionDataArgs = {
3479
- protocolFeeBp: number;
3480
- feeRecipient: Address;
3481
- };
3482
- declare function getUpdateCentralStateInstructionDataEncoder(): FixedSizeEncoder<UpdateCentralStateInstructionDataArgs>;
3483
- declare function getUpdateCentralStateInstructionDataDecoder(): FixedSizeDecoder<UpdateCentralStateInstructionData>;
3484
- declare function getUpdateCentralStateInstructionDataCodec(): FixedSizeCodec<UpdateCentralStateInstructionDataArgs, UpdateCentralStateInstructionData>;
3485
- type UpdateCentralStateAsyncInput<TAccountAuthority extends string = string, TAccountCentralState extends string = string> = {
3486
- authority: TransactionSigner<TAccountAuthority>;
3487
- centralState?: Address<TAccountCentralState>;
3488
- protocolFeeBp: UpdateCentralStateInstructionDataArgs['protocolFeeBp'];
3489
- feeRecipient: UpdateCentralStateInstructionDataArgs['feeRecipient'];
3490
- };
3491
- declare function getUpdateCentralStateInstructionAsync<TAccountAuthority extends string, TAccountCentralState extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: UpdateCentralStateAsyncInput<TAccountAuthority, TAccountCentralState>, config?: {
3492
- programAddress?: TProgramAddress;
3493
- }): Promise<UpdateCentralStateInstruction<TProgramAddress, TAccountAuthority, TAccountCentralState>>;
3494
- type UpdateCentralStateInput<TAccountAuthority extends string = string, TAccountCentralState extends string = string> = {
3495
- authority: TransactionSigner<TAccountAuthority>;
3496
- centralState: Address<TAccountCentralState>;
3497
- protocolFeeBp: UpdateCentralStateInstructionDataArgs['protocolFeeBp'];
3498
- feeRecipient: UpdateCentralStateInstructionDataArgs['feeRecipient'];
3499
- };
3500
- declare function getUpdateCentralStateInstruction<TAccountAuthority extends string, TAccountCentralState extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: UpdateCentralStateInput<TAccountAuthority, TAccountCentralState>, config?: {
3680
+ platformFeeBp: number;
3681
+ rewardPoolFeeBp: number;
3682
+ creatorFeeBp: number;
3683
+ minTimeToStakeSeconds: bigint;
3684
+ minRevealPeriodSeconds: bigint;
3685
+ maxRevealPeriodSeconds: bigint;
3686
+ marketResolutionDeadlineSeconds: bigint;
3687
+ };
3688
+ type UpdatePlatformConfigInstructionDataArgs = {
3689
+ platformFeeBp: number;
3690
+ rewardPoolFeeBp: number;
3691
+ creatorFeeBp: number;
3692
+ minTimeToStakeSeconds: number | bigint;
3693
+ minRevealPeriodSeconds: number | bigint;
3694
+ maxRevealPeriodSeconds: number | bigint;
3695
+ marketResolutionDeadlineSeconds: number | bigint;
3696
+ };
3697
+ declare function getUpdatePlatformConfigInstructionDataEncoder(): FixedSizeEncoder<UpdatePlatformConfigInstructionDataArgs>;
3698
+ declare function getUpdatePlatformConfigInstructionDataDecoder(): FixedSizeDecoder<UpdatePlatformConfigInstructionData>;
3699
+ declare function getUpdatePlatformConfigInstructionDataCodec(): FixedSizeCodec<UpdatePlatformConfigInstructionDataArgs, UpdatePlatformConfigInstructionData>;
3700
+ type UpdatePlatformConfigInput<TAccountUpdateAuthority extends string = string, TAccountPlatformConfig extends string = string> = {
3701
+ updateAuthority: TransactionSigner<TAccountUpdateAuthority>;
3702
+ platformConfig: Address<TAccountPlatformConfig>;
3703
+ platformFeeBp: UpdatePlatformConfigInstructionDataArgs['platformFeeBp'];
3704
+ rewardPoolFeeBp: UpdatePlatformConfigInstructionDataArgs['rewardPoolFeeBp'];
3705
+ creatorFeeBp: UpdatePlatformConfigInstructionDataArgs['creatorFeeBp'];
3706
+ minTimeToStakeSeconds: UpdatePlatformConfigInstructionDataArgs['minTimeToStakeSeconds'];
3707
+ minRevealPeriodSeconds: UpdatePlatformConfigInstructionDataArgs['minRevealPeriodSeconds'];
3708
+ maxRevealPeriodSeconds: UpdatePlatformConfigInstructionDataArgs['maxRevealPeriodSeconds'];
3709
+ marketResolutionDeadlineSeconds: UpdatePlatformConfigInstructionDataArgs['marketResolutionDeadlineSeconds'];
3710
+ };
3711
+ declare function getUpdatePlatformConfigInstruction<TAccountUpdateAuthority extends string, TAccountPlatformConfig extends string, TProgramAddress extends Address = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS>(input: UpdatePlatformConfigInput<TAccountUpdateAuthority, TAccountPlatformConfig>, config?: {
3501
3712
  programAddress?: TProgramAddress;
3502
- }): UpdateCentralStateInstruction<TProgramAddress, TAccountAuthority, TAccountCentralState>;
3503
- type ParsedUpdateCentralStateInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
3713
+ }): UpdatePlatformConfigInstruction<TProgramAddress, TAccountUpdateAuthority, TAccountPlatformConfig>;
3714
+ type ParsedUpdatePlatformConfigInstruction<TProgram extends string = typeof OPPORTUNITY_MARKET_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
3504
3715
  programAddress: Address<TProgram>;
3505
3716
  accounts: {
3506
- authority: TAccountMetas[0];
3507
- centralState: TAccountMetas[1];
3717
+ updateAuthority: TAccountMetas[0];
3718
+ platformConfig: TAccountMetas[1];
3508
3719
  };
3509
- data: UpdateCentralStateInstructionData;
3720
+ data: UpdatePlatformConfigInstructionData;
3510
3721
  };
3511
- declare function parseUpdateCentralStateInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedUpdateCentralStateInstruction<TProgram, TAccountMetas>;
3722
+ declare function parseUpdatePlatformConfigInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedUpdatePlatformConfigInstruction<TProgram, TAccountMetas>;
3512
3723
 
3513
3724
  /**
3514
3725
  * This code was AUTOGENERATED using the Codama library.
@@ -3542,7 +3753,6 @@ type WithdrawRewardAsyncInput<TAccountSponsor extends string = string, TAccountM
3542
3753
  market: Address<TAccountMarket>;
3543
3754
  sponsorAccount?: Address<TAccountSponsorAccount>;
3544
3755
  tokenMint: Address<TAccountTokenMint>;
3545
- /** Market's ATA holding reward tokens */
3546
3756
  marketTokenAta?: Address<TAccountMarketTokenAta>;
3547
3757
  /** Sponsor's destination for refunded reward tokens */
3548
3758
  refundTokenAccount: Address<TAccountRefundTokenAccount>;
@@ -3556,7 +3766,6 @@ type WithdrawRewardInput<TAccountSponsor extends string = string, TAccountMarket
3556
3766
  market: Address<TAccountMarket>;
3557
3767
  sponsorAccount: Address<TAccountSponsorAccount>;
3558
3768
  tokenMint: Address<TAccountTokenMint>;
3559
- /** Market's ATA holding reward tokens */
3560
3769
  marketTokenAta: Address<TAccountMarketTokenAta>;
3561
3770
  /** Sponsor's destination for refunded reward tokens */
3562
3771
  refundTokenAccount: Address<TAccountRefundTokenAccount>;
@@ -3572,7 +3781,6 @@ type ParsedWithdrawRewardInstruction<TProgram extends string = typeof OPPORTUNIT
3572
3781
  market: TAccountMetas[1];
3573
3782
  sponsorAccount: TAccountMetas[2];
3574
3783
  tokenMint: TAccountMetas[3];
3575
- /** Market's ATA holding reward tokens */
3576
3784
  marketTokenAta: TAccountMetas[4];
3577
3785
  /** Sponsor's destination for refunded reward tokens */
3578
3786
  refundTokenAccount: TAccountMetas[5];
@@ -3586,12 +3794,6 @@ interface BaseInstructionParams {
3586
3794
  programAddress?: Address;
3587
3795
  }
3588
3796
 
3589
- interface InitTokenVaultParams extends BaseInstructionParams {
3590
- payer: TransactionSigner;
3591
- tokenMint: Address;
3592
- }
3593
- declare function initTokenVault(input: InitTokenVaultParams): Promise<InitTokenVaultInstruction<string>>;
3594
-
3595
3797
  /**
3596
3798
  * Generates a random computation offset for Arcium computations.
3597
3799
  * Returns a BigInt from 8 random bytes.
@@ -3615,17 +3817,18 @@ declare function toNumberArray(bytes: ByteArray): number[];
3615
3817
 
3616
3818
  interface CreateMarketParams extends BaseInstructionParams {
3617
3819
  creator: TransactionSigner;
3820
+ platformConfig: Address;
3618
3821
  tokenMint: Address;
3619
3822
  tokenProgram: Address;
3620
3823
  marketIndex: bigint;
3621
- timeToStake: bigint;
3622
- timeToReveal: bigint;
3623
- marketAuthority: Address | null;
3624
- unstakeDelaySeconds: bigint;
3824
+ marketAuthority: Address;
3825
+ allowUnstakingEarly: boolean;
3625
3826
  authorizedReaderPubkey: ByteArray;
3626
- allowClosingEarly: boolean;
3627
3827
  revealPeriodAuthority: Address;
3628
3828
  earlinessCutoffSeconds: bigint;
3829
+ earlinessMultiplier: number;
3830
+ minStakeAmount: bigint;
3831
+ creatorFeeClaimer: Address;
3629
3832
  }
3630
3833
  declare function createMarket(input: CreateMarketParams): Promise<CreateMarketInstruction<string>>;
3631
3834
 
@@ -3633,7 +3836,10 @@ type CompDefCircuitName = "stake" | "reveal_stake";
3633
3836
  declare const ALL_COMP_DEF_CIRCUITS: CompDefCircuitName[];
3634
3837
  interface InitCompDefConfig extends BaseInstructionParams {
3635
3838
  }
3636
- declare function getMxeAccount(rpc: Rpc<SolanaRpcApi>, programId?: Address): Promise<_solana_accounts.Account<MXEAccount, string>>;
3839
+ declare function getMxeAccount(rpc: Rpc<SolanaRpcApi>, programId?: Address): Promise<{
3840
+ address: Address;
3841
+ data: MXEAccount;
3842
+ }>;
3637
3843
  declare function getCompDefAccount(circuitName: CompDefCircuitName, programId?: Address): Address;
3638
3844
  declare function getCompDefOffsetNumber(circuitName: CompDefCircuitName): number;
3639
3845
  declare function getInitCompDefInstruction(rpc: Rpc<SolanaRpcApi>, payer: TransactionSigner, circuitName: CompDefCircuitName, config?: InitCompDefConfig): Promise<Instruction>;
@@ -3648,18 +3854,21 @@ interface StakeParams extends BaseInstructionParams {
3648
3854
  signer: TransactionSigner;
3649
3855
  payer: TransactionSigner;
3650
3856
  market: Address;
3857
+ /** PDA of the stake_account being staked into. Use `getStakeAccountAddress(owner, market, id)`. */
3858
+ stakeAccount: Address;
3651
3859
  stakeAccountId: number;
3652
3860
  tokenMint: Address;
3653
3861
  signerTokenAccount: Address;
3654
- marketTokenAta: Address;
3655
- tokenVault: Address;
3656
- tokenVaultAta: Address;
3657
3862
  tokenProgram: Address;
3863
+ /** Gross amount (net + fee). Fee is deducted on-chain and routed to the fee vault ATA. */
3658
3864
  amount: bigint;
3659
3865
  selectedOptionCiphertext: ByteArray;
3660
3866
  inputNonce: bigint;
3661
3867
  authorizedReaderNonce: bigint;
3868
+ /** User's x25519 public key (NOT their Solana wallet pubkey). */
3662
3869
  userPubkey: ByteArray;
3870
+ /** u128 nonce committed to encrypted-state derivation. */
3871
+ stateNonce: bigint;
3663
3872
  }
3664
3873
  declare function stake(input: StakeParams, config: ArciumConfig): Promise<StakeInstruction<string>>;
3665
3874
 
@@ -3672,40 +3881,48 @@ interface RevealStakeParams extends BaseInstructionParams {
3672
3881
  declare function revealStake(input: RevealStakeParams, config: ArciumConfig): Promise<RevealStakeInstruction<string>>;
3673
3882
 
3674
3883
  interface AddMarketOptionParams extends BaseInstructionParams {
3675
- creator: TransactionSigner;
3884
+ signer: TransactionSigner;
3676
3885
  market: Address;
3677
3886
  optionId: number | bigint;
3678
3887
  }
3679
3888
  declare function addMarketOption(input: AddMarketOptionParams): Promise<AddMarketOptionInstruction<string>>;
3680
3889
 
3681
3890
  interface OpenMarketParams extends BaseInstructionParams {
3682
- creator: TransactionSigner;
3891
+ marketAuthority: TransactionSigner;
3683
3892
  market: Address;
3684
- openTimestamp: bigint;
3893
+ platformConfig: Address;
3894
+ timeToStake: bigint;
3685
3895
  }
3686
3896
  declare function openMarket(input: OpenMarketParams): OpenMarketInstruction<string>;
3687
3897
 
3688
- interface PauseMarketParams extends BaseInstructionParams {
3689
- authority: TransactionSigner;
3898
+ interface PauseStakingParams extends BaseInstructionParams {
3899
+ marketAuthority: TransactionSigner;
3900
+ market: Address;
3901
+ }
3902
+ declare function pauseStaking(input: PauseStakingParams): PauseStakingInstruction<string>;
3903
+
3904
+ interface ResumeStakingParams extends BaseInstructionParams {
3905
+ marketAuthority: TransactionSigner;
3690
3906
  market: Address;
3691
3907
  }
3692
- declare function pauseMarket(input: PauseMarketParams): PauseMarketInstruction<string>;
3908
+ declare function resumeStaking(input: ResumeStakingParams): ResumeStakingInstruction<string>;
3693
3909
 
3694
- interface ResumeMarketParams extends BaseInstructionParams {
3695
- authority: TransactionSigner;
3910
+ interface SetWinningOptionParams extends BaseInstructionParams {
3911
+ marketAuthority: TransactionSigner;
3696
3912
  market: Address;
3913
+ optionId: number | bigint;
3914
+ rewardPercentageBp: number;
3697
3915
  }
3698
- declare function resumeMarket(input: ResumeMarketParams): ResumeMarketInstruction<string>;
3916
+ declare function setWinningOption(input: SetWinningOptionParams): Promise<SetWinningOptionInstruction<string>>;
3699
3917
 
3700
- interface SelectWinningOptionsParams extends BaseInstructionParams {
3701
- authority: TransactionSigner;
3918
+ interface ResolveMarketParams extends BaseInstructionParams {
3919
+ marketAuthority: TransactionSigner;
3702
3920
  market: Address;
3703
- selections: Array<WinningOptionArgs>;
3704
3921
  }
3705
- declare function selectWinningOptions(input: SelectWinningOptionsParams): SelectWinningOptionsInstruction<string>;
3922
+ declare function resolveMarket(input: ResolveMarketParams): ResolveMarketInstruction<string>;
3706
3923
 
3707
3924
  interface EndRevealPeriodParams extends BaseInstructionParams {
3708
- authority: TransactionSigner;
3925
+ signer: TransactionSigner;
3709
3926
  market: Address;
3710
3927
  }
3711
3928
  declare function endRevealPeriod(input: EndRevealPeriodParams): EndRevealPeriodInstruction<string>;
@@ -3722,13 +3939,20 @@ interface AddRewardParams extends BaseInstructionParams {
3722
3939
  declare function addReward(input: AddRewardParams): Promise<AddRewardInstruction<string>>;
3723
3940
 
3724
3941
  interface InitStakeAccountParams extends BaseInstructionParams {
3725
- signer: TransactionSigner;
3942
+ payer: TransactionSigner;
3943
+ owner: Address;
3726
3944
  market: Address;
3727
- stateNonce: bigint;
3728
3945
  stakeAccountId: number;
3729
3946
  }
3730
3947
  declare function initStakeAccount(input: InitStakeAccountParams): Promise<InitStakeAccountInstruction<string>>;
3731
3948
 
3949
+ interface InitAllowedMintParams extends BaseInstructionParams {
3950
+ updateAuthority: TransactionSigner;
3951
+ platformConfig: Address;
3952
+ tokenMint: Address;
3953
+ }
3954
+ declare function initAllowedMint(input: InitAllowedMintParams): Promise<InitAllowedMintInstruction<string>>;
3955
+
3732
3956
  interface CloseStakeAccountParams extends BaseInstructionParams {
3733
3957
  owner: TransactionSigner;
3734
3958
  market: Address;
@@ -3750,52 +3974,79 @@ interface CloseStuckStakeAccountParams extends BaseInstructionParams {
3750
3974
  }
3751
3975
  declare function closeStuckStakeAccount(input: CloseStuckStakeAccountParams): Promise<CloseStuckStakeAccountInstruction<string>>;
3752
3976
 
3753
- interface ReclaimStakeParams extends BaseInstructionParams {
3977
+ interface CloseOptionAccountParams extends BaseInstructionParams {
3978
+ signer: TransactionSigner;
3979
+ creator: Address;
3980
+ market: Address;
3981
+ optionId: number | bigint;
3982
+ }
3983
+ declare function closeOptionAccount(input: CloseOptionAccountParams): Promise<CloseOptionAccountInstruction<string>>;
3984
+
3985
+ interface UnstakeParams extends BaseInstructionParams {
3754
3986
  signer: TransactionSigner;
3755
3987
  owner: Address;
3756
3988
  market: Address;
3757
3989
  tokenMint: Address;
3758
- marketTokenAta: Address;
3759
3990
  ownerTokenAccount: Address;
3760
3991
  tokenProgram: Address;
3761
3992
  stakeAccountId: number;
3762
3993
  }
3763
- declare function reclaimStake(input: ReclaimStakeParams): Promise<ReclaimStakeInstruction<string>>;
3994
+ declare function unstake(input: UnstakeParams): Promise<UnstakeInstruction<string>>;
3764
3995
 
3765
- interface IncrementOptionTallyParams extends BaseInstructionParams {
3996
+ interface FinalizeRevealStakeParams extends BaseInstructionParams {
3766
3997
  signer: TransactionSigner;
3767
3998
  owner: Address;
3768
3999
  market: Address;
3769
4000
  optionId: number | bigint;
3770
4001
  stakeAccountId: number;
3771
4002
  }
3772
- declare function incrementOptionTally(input: IncrementOptionTallyParams): Promise<IncrementOptionTallyInstruction<string>>;
4003
+ declare function finalizeRevealStake(input: FinalizeRevealStakeParams): Promise<FinalizeRevealStakeInstruction<string>>;
3773
4004
 
3774
- interface UnstakeEarlyParams extends BaseInstructionParams {
4005
+ interface CreatePlatformConfigParams extends BaseInstructionParams {
3775
4006
  signer: TransactionSigner;
3776
- market: Address;
3777
- stakeAccountId: number;
4007
+ name: string;
4008
+ platformFeeBp: number;
4009
+ rewardPoolFeeBp: number;
4010
+ creatorFeeBp: number;
4011
+ feeClaimAuthority: Address;
4012
+ minTimeToStakeSeconds: bigint;
4013
+ minRevealPeriodSeconds: bigint;
4014
+ maxRevealPeriodSeconds: bigint;
4015
+ marketResolutionDeadlineSeconds: bigint;
4016
+ }
4017
+ declare function createPlatformConfig(rpc: Parameters<typeof fetchMaybePlatformConfig>[0], params: CreatePlatformConfigParams): Promise<Instruction>;
4018
+
4019
+ interface UpdatePlatformConfigParams extends BaseInstructionParams {
4020
+ signer: TransactionSigner;
4021
+ name: string;
4022
+ platformFeeBp: number;
4023
+ rewardPoolFeeBp: number;
4024
+ creatorFeeBp: number;
4025
+ minTimeToStakeSeconds: bigint;
4026
+ minRevealPeriodSeconds: bigint;
4027
+ maxRevealPeriodSeconds: bigint;
4028
+ marketResolutionDeadlineSeconds: bigint;
3778
4029
  }
3779
- declare function unstakeEarly(input: UnstakeEarlyParams): Promise<UnstakeEarlyInstruction<string>>;
4030
+ declare function updatePlatformConfig(rpc: Parameters<typeof fetchMaybePlatformConfig>[0], params: UpdatePlatformConfigParams): Promise<Instruction>;
3780
4031
 
3781
- interface DoUnstakeEarlyParams extends BaseInstructionParams {
4032
+ interface ClaimFeesParams extends BaseInstructionParams {
3782
4033
  signer: TransactionSigner;
3783
4034
  market: Address;
4035
+ platformConfig: Address;
3784
4036
  tokenMint: Address;
3785
- marketTokenAta: Address;
3786
- ownerTokenAccount: Address;
4037
+ destinationTokenAccount: Address;
3787
4038
  tokenProgram: Address;
3788
- stakeAccountId: number;
3789
- stakeAccountOwner: Address;
3790
4039
  }
3791
- declare function doUnstakeEarly(input: DoUnstakeEarlyParams): Promise<DoUnstakeEarlyInstruction<string>>;
4040
+ declare function claimFees(input: ClaimFeesParams): Promise<ClaimFeesInstruction<string>>;
3792
4041
 
3793
- interface EnsureCentralStateParams extends BaseInstructionParams {
4042
+ interface ClaimCreatorFeesParams extends BaseInstructionParams {
3794
4043
  signer: TransactionSigner;
3795
- protocolFeeBp: number;
3796
- feeRecipient: Address;
4044
+ market: Address;
4045
+ tokenMint: Address;
4046
+ destinationTokenAccount: Address;
4047
+ tokenProgram: Address;
3797
4048
  }
3798
- declare function ensureCentralState(rpc: Parameters<typeof fetchMaybeCentralState>[0], params: EnsureCentralStateParams): Promise<Instruction | null>;
4049
+ declare function claimCreatorFees(input: ClaimCreatorFeesParams): Promise<ClaimCreatorFeesInstruction<string>>;
3799
4050
 
3800
4051
  interface WithdrawRewardParams extends BaseInstructionParams {
3801
4052
  sponsor: TransactionSigner;
@@ -3806,11 +4057,28 @@ interface WithdrawRewardParams extends BaseInstructionParams {
3806
4057
  }
3807
4058
  declare function withdrawReward(input: WithdrawRewardParams): Promise<WithdrawRewardInstruction<string>>;
3808
4059
 
3809
- declare const CENTRAL_STATE_SEED = "central_state";
3810
- declare function getCentralStateAddress(programId?: Address): Promise<ProgramDerivedAddress>;
4060
+ interface SetUpdateAuthorityParams extends BaseInstructionParams {
4061
+ updateAuthority: TransactionSigner;
4062
+ platformConfig: Address;
4063
+ newAuthority: Address;
4064
+ }
4065
+ declare function setUpdateAuthority(input: SetUpdateAuthorityParams): SetUpdateAuthorityInstruction<string>;
4066
+
4067
+ interface SetFeeClaimAuthorityParams extends BaseInstructionParams {
4068
+ updateAuthority: TransactionSigner;
4069
+ platformConfig: Address;
4070
+ newFeeClaimAuthority: Address;
4071
+ }
4072
+ declare function setFeeClaimAuthority(input: SetFeeClaimAuthorityParams): SetFeeClaimAuthorityInstruction<string>;
4073
+
4074
+ declare const PLATFORM_CONFIG_SEED = "platform_config";
4075
+ declare function getPlatformConfigAddress(authority: Address, name: string, programId?: Address): Promise<ProgramDerivedAddress>;
4076
+
4077
+ declare const ALLOWED_MINT_SEED = "allowed_mint";
4078
+ declare function getAllowedMintAddress(platformConfig: Address, mint: Address, programId?: Address): Promise<ProgramDerivedAddress>;
3811
4079
 
3812
4080
  declare const OPPORTUNITY_MARKET_SEED = "opportunity_market";
3813
- declare function getOpportunityMarketAddress(creator: Address, marketIndex: bigint | number, programId?: Address): Promise<ProgramDerivedAddress>;
4081
+ declare function getOpportunityMarketAddress(platformConfig: Address, creator: Address, marketIndex: bigint | number, programId?: Address): Promise<ProgramDerivedAddress>;
3814
4082
 
3815
4083
  declare const OPPORTUNITY_MARKET_OPTION_SEED = "option";
3816
4084
  declare function getOpportunityMarketOptionAddress(market: Address, optionId: number | bigint, programId?: Address): Promise<ProgramDerivedAddress>;
@@ -3821,9 +4089,6 @@ declare function getOpportunityMarketSponsorAddress(sponsor: Address, market: Ad
3821
4089
  declare const STAKE_ACCOUNT_SEED = "stake_account";
3822
4090
  declare function getStakeAccountAddress(owner: Address, market: Address, stakeAccountId: number, programId?: Address): Promise<ProgramDerivedAddress>;
3823
4091
 
3824
- declare const TOKEN_VAULT_SEED = "token_vault";
3825
- declare function getTokenVaultAddress(mint: Address, programId?: Address): Promise<ProgramDerivedAddress>;
3826
-
3827
4092
  interface AwaitComputationOptions {
3828
4093
  commitment?: "processed" | "confirmed" | "finalized";
3829
4094
  mxeProgramId?: Address;
@@ -3872,4 +4137,4 @@ declare function deriveSharedSecret(userSecretKey: Uint8Array, mxePublicKey: Uin
3872
4137
  declare function createCipher(userSecretKey: Uint8Array, mxePublicKey: Uint8Array): RescueCipher;
3873
4138
  declare function nonceToBytes(nonce: bigint): Uint8Array;
3874
4139
 
3875
- export { ADD_MARKET_OPTION_DISCRIMINATOR, ADD_REWARD_DISCRIMINATOR, 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 ArciumSignerAccount, type ArciumSignerAccountArgs, type AwaitComputationOptions, type BN254G2BLSPublicKey, type BN254G2BLSPublicKeyArgs, type BaseInstructionParams, type ByteArray, 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 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, type FeePool, type FeePoolArgs, type FeesClaimedEvent, type FeesClaimedEventArgs, 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__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, Parameter, type ParameterArgs, type ParsedAddMarketOptionInstruction, type ParsedAddRewardInstruction, type ParsedClaimFeesInstruction, type ParsedCloseStakeAccountInstruction, type ParsedCloseStuckStakeAccountInstruction, type ParsedCreateMarketInstruction, type ParsedDoUnstakeEarlyInstruction, type ParsedEndRevealPeriodInstruction, type ParsedIncrementOptionTallyInstruction, type ParsedInitCentralStateInstruction, type ParsedInitStakeAccountInstruction, type ParsedInitTokenVaultInstruction, type ParsedOpenMarketInstruction, type ParsedOpportunityMarketInstruction, type ParsedPauseMarketInstruction, type ParsedReclaimStakeInstruction, type ParsedResumeMarketInstruction, type ParsedRevealStakeCallbackInstruction, type ParsedRevealStakeCompDefInstruction, type ParsedRevealStakeInstruction, type ParsedSelectWinningOptionsInstruction, type ParsedStakeCallbackInstruction, type ParsedStakeCompDefInstruction, type ParsedStakeInstruction, type ParsedTransferCentralStateAuthorityInstruction, type ParsedUnstakeEarlyInstruction, type ParsedUpdateCentralStateInstruction, type ParsedWithdrawRewardInstruction, type PauseMarketInput, type PauseMarketInstruction, type PauseMarketInstructionData, type PauseMarketInstructionDataArgs, type PauseMarketParams, 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, TOKEN_VAULT_DISCRIMINATOR, TOKEN_VAULT_SEED, TRANSFER_CENTRAL_STATE_AUTHORITY_DISCRIMINATOR, type TallyIncrementedEvent, type TallyIncrementedEventArgs, type Timestamp, type TimestampArgs, type TokenVault, type TokenVaultArgs, type TransferCentralStateAuthorityAsyncInput, type TransferCentralStateAuthorityInput, type TransferCentralStateAuthorityInstruction, type TransferCentralStateAuthorityInstructionData, type TransferCentralStateAuthorityInstructionDataArgs, 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, circuitSource, closeStakeAccount, closeStuckStakeAccount, createCipher, createMarket, decodeArciumSignerAccount, decodeCentralState, decodeClockAccount, decodeCluster, decodeComputationDefinitionAccount, decodeFeePool, decodeMXEAccount, decodeOpportunityMarket, decodeOpportunityMarketOption, decodeOpportunityMarketSponsor, decodeStakeAccount, decodeTokenVault, deriveSharedSecret, deriveX25519KeypairFromSignature, doUnstakeEarly, endRevealPeriod, ensureCentralState, fetchAllArciumSignerAccount, fetchAllCentralState, fetchAllClockAccount, fetchAllCluster, fetchAllComputationDefinitionAccount, fetchAllFeePool, fetchAllMXEAccount, fetchAllMaybeArciumSignerAccount, fetchAllMaybeCentralState, fetchAllMaybeClockAccount, fetchAllMaybeCluster, fetchAllMaybeComputationDefinitionAccount, fetchAllMaybeFeePool, fetchAllMaybeMXEAccount, fetchAllMaybeOpportunityMarket, fetchAllMaybeOpportunityMarketOption, fetchAllMaybeOpportunityMarketSponsor, fetchAllMaybeStakeAccount, fetchAllMaybeTokenVault, fetchAllOpportunityMarket, fetchAllOpportunityMarketOption, fetchAllOpportunityMarketSponsor, fetchAllStakeAccount, fetchAllTokenVault, fetchArciumSignerAccount, fetchCentralState, fetchClockAccount, fetchCluster, fetchComputationDefinitionAccount, fetchFeePool, fetchMXEAccount, fetchMaybeArciumSignerAccount, fetchMaybeCentralState, fetchMaybeClockAccount, fetchMaybeCluster, fetchMaybeComputationDefinitionAccount, fetchMaybeFeePool, fetchMaybeMXEAccount, fetchMaybeOpportunityMarket, fetchMaybeOpportunityMarketOption, fetchMaybeOpportunityMarketSponsor, fetchMaybeStakeAccount, fetchMaybeTokenVault, fetchOpportunityMarket, fetchOpportunityMarketOption, fetchOpportunityMarketSponsor, fetchStakeAccount, fetchTokenVault, generateX25519Keypair, getActivationCodec, getActivationDecoder, getActivationEncoder, getAddMarketOptionDiscriminatorBytes, getAddMarketOptionInstruction, getAddMarketOptionInstructionAsync, getAddMarketOptionInstructionDataCodec, getAddMarketOptionInstructionDataDecoder, getAddMarketOptionInstructionDataEncoder, getAddRewardDiscriminatorBytes, getAddRewardInstruction, getAddRewardInstructionAsync, getAddRewardInstructionDataCodec, getAddRewardInstructionDataDecoder, getAddRewardInstructionDataEncoder, getArciumSignerAccountCodec, getArciumSignerAccountDecoder, getArciumSignerAccountDiscriminatorBytes, getArciumSignerAccountEncoder, getBN254G2BLSPublicKeyCodec, getBN254G2BLSPublicKeyDecoder, getBN254G2BLSPublicKeyEncoder, 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, 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, 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, getTimestampCodec, getTimestampDecoder, getTimestampEncoder, getTokenVaultAddress, getTokenVaultCodec, getTokenVaultDecoder, getTokenVaultDiscriminatorBytes, getTokenVaultEncoder, getTransferCentralStateAuthorityDiscriminatorBytes, getTransferCentralStateAuthorityInstruction, getTransferCentralStateAuthorityInstructionAsync, getTransferCentralStateAuthorityInstructionDataCodec, getTransferCentralStateAuthorityInstructionDataDecoder, getTransferCentralStateAuthorityInstructionDataEncoder, 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, parseClaimFeesInstruction, parseCloseStakeAccountInstruction, parseCloseStuckStakeAccountInstruction, parseCreateMarketInstruction, parseDoUnstakeEarlyInstruction, parseEndRevealPeriodInstruction, parseIncrementOptionTallyInstruction, parseInitCentralStateInstruction, parseInitStakeAccountInstruction, parseInitTokenVaultInstruction, parseOpenMarketInstruction, parsePauseMarketInstruction, parseReclaimStakeInstruction, parseResumeMarketInstruction, parseRevealStakeCallbackInstruction, parseRevealStakeCompDefInstruction, parseRevealStakeInstruction, parseSelectWinningOptionsInstruction, parseStakeCallbackInstruction, parseStakeCompDefInstruction, parseStakeInstruction, parseTransferCentralStateAuthorityInstruction, parseUnstakeEarlyInstruction, parseUpdateCentralStateInstruction, parseWithdrawRewardInstruction, pauseMarket, randomComputationOffset, randomStateNonce, reclaimStake, resumeMarket, revealStake, selectWinningOptions, stake, toNumberArray, unstakeEarly, withdrawReward };
4140
+ 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 };