@satrush/client 0.1.7 → 0.1.8
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.
- package/dist/index.d.mts +91 -6
- package/dist/index.d.ts +91 -6
- package/dist/index.js +462 -310
- package/dist/index.mjs +269 -112
- package/package.json +1 -1
package/dist/index.js
CHANGED
|
@@ -92,6 +92,8 @@ __export(index_exports, {
|
|
|
92
92
|
SATRUSH_ERROR__INVALID_SELECTION_MASK: () => SATRUSH_ERROR__INVALID_SELECTION_MASK,
|
|
93
93
|
SATRUSH_ERROR__INVALID_SHARE_AMOUNT: () => SATRUSH_ERROR__INVALID_SHARE_AMOUNT,
|
|
94
94
|
SATRUSH_ERROR__INVALID_SLOT_HASH: () => SATRUSH_ERROR__INVALID_SLOT_HASH,
|
|
95
|
+
SATRUSH_ERROR__INVALID_STRIKE_TRIGGER_MODULUS: () => SATRUSH_ERROR__INVALID_STRIKE_TRIGGER_MODULUS,
|
|
96
|
+
SATRUSH_ERROR__INVALID_SWAP_BPS: () => SATRUSH_ERROR__INVALID_SWAP_BPS,
|
|
95
97
|
SATRUSH_ERROR__INVALID_SWAP_PROGRAM: () => SATRUSH_ERROR__INVALID_SWAP_PROGRAM,
|
|
96
98
|
SATRUSH_ERROR__INVALID_TICKETS_COUNT: () => SATRUSH_ERROR__INVALID_TICKETS_COUNT,
|
|
97
99
|
SATRUSH_ERROR__INVALID_UNCLAIMED_HASHRATE_BPS: () => SATRUSH_ERROR__INVALID_UNCLAIMED_HASHRATE_BPS,
|
|
@@ -135,6 +137,7 @@ __export(index_exports, {
|
|
|
135
137
|
UPDATE_DEPLOYMENT_SETTLE_GRACE_DURATION_DISCRIMINATOR: () => UPDATE_DEPLOYMENT_SETTLE_GRACE_DURATION_DISCRIMINATOR,
|
|
136
138
|
UPDATE_EPOCH_VAULT_ITERATION_DURATION_DISCRIMINATOR: () => UPDATE_EPOCH_VAULT_ITERATION_DURATION_DISCRIMINATOR,
|
|
137
139
|
UPDATE_MIN_DEPLOY_USD_AMOUNT_DISCRIMINATOR: () => UPDATE_MIN_DEPLOY_USD_AMOUNT_DISCRIMINATOR,
|
|
140
|
+
UPDATE_STRIKE_TRIGGER_MODULUS_DISCRIMINATOR: () => UPDATE_STRIKE_TRIGGER_MODULUS_DISCRIMINATOR,
|
|
138
141
|
UPDATE_UNCLAIMED_HASHRATE_BPS_DISCRIMINATOR: () => UPDATE_UNCLAIMED_HASHRATE_BPS_DISCRIMINATOR,
|
|
139
142
|
WITHDRAW_PROTOCOL_FEES_DISCRIMINATOR: () => WITHDRAW_PROTOCOL_FEES_DISCRIMINATOR,
|
|
140
143
|
btcToSats: () => btcToSats,
|
|
@@ -593,6 +596,12 @@ __export(index_exports, {
|
|
|
593
596
|
getUpdateMinDeployUsdAmountInstructionDataCodec: () => getUpdateMinDeployUsdAmountInstructionDataCodec,
|
|
594
597
|
getUpdateMinDeployUsdAmountInstructionDataDecoder: () => getUpdateMinDeployUsdAmountInstructionDataDecoder,
|
|
595
598
|
getUpdateMinDeployUsdAmountInstructionDataEncoder: () => getUpdateMinDeployUsdAmountInstructionDataEncoder,
|
|
599
|
+
getUpdateStrikeTriggerModulusDiscriminatorBytes: () => getUpdateStrikeTriggerModulusDiscriminatorBytes,
|
|
600
|
+
getUpdateStrikeTriggerModulusInstruction: () => getUpdateStrikeTriggerModulusInstruction,
|
|
601
|
+
getUpdateStrikeTriggerModulusInstructionAsync: () => getUpdateStrikeTriggerModulusInstructionAsync,
|
|
602
|
+
getUpdateStrikeTriggerModulusInstructionDataCodec: () => getUpdateStrikeTriggerModulusInstructionDataCodec,
|
|
603
|
+
getUpdateStrikeTriggerModulusInstructionDataDecoder: () => getUpdateStrikeTriggerModulusInstructionDataDecoder,
|
|
604
|
+
getUpdateStrikeTriggerModulusInstructionDataEncoder: () => getUpdateStrikeTriggerModulusInstructionDataEncoder,
|
|
596
605
|
getUpdateUnclaimedHashrateBpsDiscriminatorBytes: () => getUpdateUnclaimedHashrateBpsDiscriminatorBytes,
|
|
597
606
|
getUpdateUnclaimedHashrateBpsInstruction: () => getUpdateUnclaimedHashrateBpsInstruction,
|
|
598
607
|
getUpdateUnclaimedHashrateBpsInstructionAsync: () => getUpdateUnclaimedHashrateBpsInstructionAsync,
|
|
@@ -651,6 +660,7 @@ __export(index_exports, {
|
|
|
651
660
|
parseUpdateDeploymentSettleGraceDurationInstruction: () => parseUpdateDeploymentSettleGraceDurationInstruction,
|
|
652
661
|
parseUpdateEpochVaultIterationDurationInstruction: () => parseUpdateEpochVaultIterationDurationInstruction,
|
|
653
662
|
parseUpdateMinDeployUsdAmountInstruction: () => parseUpdateMinDeployUsdAmountInstruction,
|
|
663
|
+
parseUpdateStrikeTriggerModulusInstruction: () => parseUpdateStrikeTriggerModulusInstruction,
|
|
654
664
|
parseUpdateUnclaimedHashrateBpsInstruction: () => parseUpdateUnclaimedHashrateBpsInstruction,
|
|
655
665
|
parseWithdrawProtocolFeesInstruction: () => parseWithdrawProtocolFeesInstruction,
|
|
656
666
|
satrushProgram: () => satrushProgram,
|
|
@@ -1028,7 +1038,9 @@ function getEpochWinnerSelectedEncoder() {
|
|
|
1028
1038
|
["winner", (0, import_kit8.getAddressEncoder)()],
|
|
1029
1039
|
["rank", (0, import_kit8.getU8Encoder)()],
|
|
1030
1040
|
["pageIndex", (0, import_kit8.getU16Encoder)()],
|
|
1031
|
-
["winningTicket", (0, import_kit8.getU64Encoder)()]
|
|
1041
|
+
["winningTicket", (0, import_kit8.getU64Encoder)()],
|
|
1042
|
+
["wonUsdAmount", (0, import_kit8.getU64Encoder)()],
|
|
1043
|
+
["wonBtcAmount", (0, import_kit8.getU64Encoder)()]
|
|
1032
1044
|
]),
|
|
1033
1045
|
[
|
|
1034
1046
|
(0, import_kit8.getConstantEncoder)(
|
|
@@ -1046,7 +1058,9 @@ function getEpochWinnerSelectedDecoder() {
|
|
|
1046
1058
|
["winner", (0, import_kit8.getAddressDecoder)()],
|
|
1047
1059
|
["rank", (0, import_kit8.getU8Decoder)()],
|
|
1048
1060
|
["pageIndex", (0, import_kit8.getU16Decoder)()],
|
|
1049
|
-
["winningTicket", (0, import_kit8.getU64Decoder)()]
|
|
1061
|
+
["winningTicket", (0, import_kit8.getU64Decoder)()],
|
|
1062
|
+
["wonUsdAmount", (0, import_kit8.getU64Decoder)()],
|
|
1063
|
+
["wonBtcAmount", (0, import_kit8.getU64Decoder)()]
|
|
1050
1064
|
]),
|
|
1051
1065
|
[
|
|
1052
1066
|
(0, import_kit8.getConstantDecoder)(
|
|
@@ -2270,7 +2284,8 @@ function getSatrushConfigEncoder() {
|
|
|
2270
2284
|
["minDeployUsdAmount", (0, import_kit30.getU64Encoder)()],
|
|
2271
2285
|
["epochVaultIterationDuration", (0, import_kit30.getU64Encoder)()],
|
|
2272
2286
|
["deploymentSettleGraceDuration", (0, import_kit30.getU64Encoder)()],
|
|
2273
|
-
["
|
|
2287
|
+
["strikeTriggerModulus", (0, import_kit30.getU16Encoder)()],
|
|
2288
|
+
["reserved", (0, import_kit30.fixEncoderSize)((0, import_kit30.getBytesEncoder)(), 30)]
|
|
2274
2289
|
]),
|
|
2275
2290
|
(value) => ({ ...value, discriminator: SATRUSH_CONFIG_DISCRIMINATOR })
|
|
2276
2291
|
);
|
|
@@ -2296,7 +2311,8 @@ function getSatrushConfigDecoder() {
|
|
|
2296
2311
|
["minDeployUsdAmount", (0, import_kit30.getU64Decoder)()],
|
|
2297
2312
|
["epochVaultIterationDuration", (0, import_kit30.getU64Decoder)()],
|
|
2298
2313
|
["deploymentSettleGraceDuration", (0, import_kit30.getU64Decoder)()],
|
|
2299
|
-
["
|
|
2314
|
+
["strikeTriggerModulus", (0, import_kit30.getU16Decoder)()],
|
|
2315
|
+
["reserved", (0, import_kit30.fixDecoderSize)((0, import_kit30.getBytesDecoder)(), 30)]
|
|
2300
2316
|
]);
|
|
2301
2317
|
}
|
|
2302
2318
|
function getSatrushConfigCodec() {
|
|
@@ -2475,11 +2491,11 @@ function getTreasurySize() {
|
|
|
2475
2491
|
}
|
|
2476
2492
|
|
|
2477
2493
|
// src/generated/errors/satrush.ts
|
|
2478
|
-
var
|
|
2494
|
+
var import_kit86 = require("@solana/kit");
|
|
2479
2495
|
|
|
2480
2496
|
// src/generated/programs/satrush.ts
|
|
2481
|
-
var
|
|
2482
|
-
var
|
|
2497
|
+
var import_kit85 = require("@solana/kit");
|
|
2498
|
+
var import_program_client_core41 = require("@solana/program-client-core");
|
|
2483
2499
|
|
|
2484
2500
|
// src/generated/instructions/buyEpochTickets.ts
|
|
2485
2501
|
var import_kit45 = require("@solana/kit");
|
|
@@ -10814,35 +10830,136 @@ function parseUpdateMinDeployUsdAmountInstruction(instruction) {
|
|
|
10814
10830
|
};
|
|
10815
10831
|
}
|
|
10816
10832
|
|
|
10817
|
-
// src/generated/instructions/
|
|
10833
|
+
// src/generated/instructions/updateStrikeTriggerModulus.ts
|
|
10818
10834
|
var import_kit82 = require("@solana/kit");
|
|
10819
10835
|
var import_program_client_core38 = require("@solana/program-client-core");
|
|
10820
|
-
var
|
|
10821
|
-
function
|
|
10836
|
+
var UPDATE_STRIKE_TRIGGER_MODULUS_DISCRIMINATOR = new Uint8Array([241, 172, 229, 62, 191, 163, 60, 186]);
|
|
10837
|
+
function getUpdateStrikeTriggerModulusDiscriminatorBytes() {
|
|
10822
10838
|
return (0, import_kit82.fixEncoderSize)((0, import_kit82.getBytesEncoder)(), 8).encode(
|
|
10823
|
-
|
|
10839
|
+
UPDATE_STRIKE_TRIGGER_MODULUS_DISCRIMINATOR
|
|
10824
10840
|
);
|
|
10825
10841
|
}
|
|
10826
|
-
function
|
|
10842
|
+
function getUpdateStrikeTriggerModulusInstructionDataEncoder() {
|
|
10827
10843
|
return (0, import_kit82.transformEncoder)(
|
|
10828
10844
|
(0, import_kit82.getStructEncoder)([
|
|
10829
10845
|
["discriminator", (0, import_kit82.fixEncoderSize)((0, import_kit82.getBytesEncoder)(), 8)],
|
|
10830
|
-
["
|
|
10846
|
+
["newModulus", (0, import_kit82.getU16Encoder)()]
|
|
10831
10847
|
]),
|
|
10832
10848
|
(value) => ({
|
|
10833
10849
|
...value,
|
|
10834
|
-
discriminator:
|
|
10850
|
+
discriminator: UPDATE_STRIKE_TRIGGER_MODULUS_DISCRIMINATOR
|
|
10835
10851
|
})
|
|
10836
10852
|
);
|
|
10837
10853
|
}
|
|
10838
|
-
function
|
|
10854
|
+
function getUpdateStrikeTriggerModulusInstructionDataDecoder() {
|
|
10839
10855
|
return (0, import_kit82.getStructDecoder)([
|
|
10840
10856
|
["discriminator", (0, import_kit82.fixDecoderSize)((0, import_kit82.getBytesDecoder)(), 8)],
|
|
10841
|
-
["
|
|
10857
|
+
["newModulus", (0, import_kit82.getU16Decoder)()]
|
|
10842
10858
|
]);
|
|
10843
10859
|
}
|
|
10844
|
-
function
|
|
10860
|
+
function getUpdateStrikeTriggerModulusInstructionDataCodec() {
|
|
10845
10861
|
return (0, import_kit82.combineCodec)(
|
|
10862
|
+
getUpdateStrikeTriggerModulusInstructionDataEncoder(),
|
|
10863
|
+
getUpdateStrikeTriggerModulusInstructionDataDecoder()
|
|
10864
|
+
);
|
|
10865
|
+
}
|
|
10866
|
+
async function getUpdateStrikeTriggerModulusInstructionAsync(input, config) {
|
|
10867
|
+
const programAddress = config?.programAddress ?? SATRUSH_PROGRAM_ADDRESS;
|
|
10868
|
+
const originalAccounts = {
|
|
10869
|
+
authority: { value: input.authority ?? null, isWritable: false },
|
|
10870
|
+
satrushConfig: { value: input.satrushConfig ?? null, isWritable: true }
|
|
10871
|
+
};
|
|
10872
|
+
const accounts = originalAccounts;
|
|
10873
|
+
const args = { ...input };
|
|
10874
|
+
if (!accounts.satrushConfig.value) {
|
|
10875
|
+
accounts.satrushConfig.value = await findSatrushConfigPda();
|
|
10876
|
+
}
|
|
10877
|
+
const getAccountMeta = (0, import_program_client_core38.getAccountMetaFactory)(programAddress, "programId");
|
|
10878
|
+
return Object.freeze({
|
|
10879
|
+
accounts: [
|
|
10880
|
+
getAccountMeta("authority", accounts.authority),
|
|
10881
|
+
getAccountMeta("satrushConfig", accounts.satrushConfig)
|
|
10882
|
+
],
|
|
10883
|
+
data: getUpdateStrikeTriggerModulusInstructionDataEncoder().encode(
|
|
10884
|
+
args
|
|
10885
|
+
),
|
|
10886
|
+
programAddress
|
|
10887
|
+
});
|
|
10888
|
+
}
|
|
10889
|
+
function getUpdateStrikeTriggerModulusInstruction(input, config) {
|
|
10890
|
+
const programAddress = config?.programAddress ?? SATRUSH_PROGRAM_ADDRESS;
|
|
10891
|
+
const originalAccounts = {
|
|
10892
|
+
authority: { value: input.authority ?? null, isWritable: false },
|
|
10893
|
+
satrushConfig: { value: input.satrushConfig ?? null, isWritable: true }
|
|
10894
|
+
};
|
|
10895
|
+
const accounts = originalAccounts;
|
|
10896
|
+
const args = { ...input };
|
|
10897
|
+
const getAccountMeta = (0, import_program_client_core38.getAccountMetaFactory)(programAddress, "programId");
|
|
10898
|
+
return Object.freeze({
|
|
10899
|
+
accounts: [
|
|
10900
|
+
getAccountMeta("authority", accounts.authority),
|
|
10901
|
+
getAccountMeta("satrushConfig", accounts.satrushConfig)
|
|
10902
|
+
],
|
|
10903
|
+
data: getUpdateStrikeTriggerModulusInstructionDataEncoder().encode(
|
|
10904
|
+
args
|
|
10905
|
+
),
|
|
10906
|
+
programAddress
|
|
10907
|
+
});
|
|
10908
|
+
}
|
|
10909
|
+
function parseUpdateStrikeTriggerModulusInstruction(instruction) {
|
|
10910
|
+
if (instruction.accounts.length < 2) {
|
|
10911
|
+
throw new import_kit82.SolanaError(
|
|
10912
|
+
import_kit82.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
|
|
10913
|
+
{
|
|
10914
|
+
actualAccountMetas: instruction.accounts.length,
|
|
10915
|
+
expectedAccountMetas: 2
|
|
10916
|
+
}
|
|
10917
|
+
);
|
|
10918
|
+
}
|
|
10919
|
+
let accountIndex = 0;
|
|
10920
|
+
const getNextAccount = () => {
|
|
10921
|
+
const accountMeta = instruction.accounts[accountIndex];
|
|
10922
|
+
accountIndex += 1;
|
|
10923
|
+
return accountMeta;
|
|
10924
|
+
};
|
|
10925
|
+
return {
|
|
10926
|
+
programAddress: instruction.programAddress,
|
|
10927
|
+
accounts: { authority: getNextAccount(), satrushConfig: getNextAccount() },
|
|
10928
|
+
data: getUpdateStrikeTriggerModulusInstructionDataDecoder().decode(
|
|
10929
|
+
instruction.data
|
|
10930
|
+
)
|
|
10931
|
+
};
|
|
10932
|
+
}
|
|
10933
|
+
|
|
10934
|
+
// src/generated/instructions/updateUnclaimedHashrateBps.ts
|
|
10935
|
+
var import_kit83 = require("@solana/kit");
|
|
10936
|
+
var import_program_client_core39 = require("@solana/program-client-core");
|
|
10937
|
+
var UPDATE_UNCLAIMED_HASHRATE_BPS_DISCRIMINATOR = new Uint8Array([237, 38, 26, 14, 73, 161, 208, 157]);
|
|
10938
|
+
function getUpdateUnclaimedHashrateBpsDiscriminatorBytes() {
|
|
10939
|
+
return (0, import_kit83.fixEncoderSize)((0, import_kit83.getBytesEncoder)(), 8).encode(
|
|
10940
|
+
UPDATE_UNCLAIMED_HASHRATE_BPS_DISCRIMINATOR
|
|
10941
|
+
);
|
|
10942
|
+
}
|
|
10943
|
+
function getUpdateUnclaimedHashrateBpsInstructionDataEncoder() {
|
|
10944
|
+
return (0, import_kit83.transformEncoder)(
|
|
10945
|
+
(0, import_kit83.getStructEncoder)([
|
|
10946
|
+
["discriminator", (0, import_kit83.fixEncoderSize)((0, import_kit83.getBytesEncoder)(), 8)],
|
|
10947
|
+
["newUnclaimedHashrateBps", (0, import_kit83.getU32Encoder)()]
|
|
10948
|
+
]),
|
|
10949
|
+
(value) => ({
|
|
10950
|
+
...value,
|
|
10951
|
+
discriminator: UPDATE_UNCLAIMED_HASHRATE_BPS_DISCRIMINATOR
|
|
10952
|
+
})
|
|
10953
|
+
);
|
|
10954
|
+
}
|
|
10955
|
+
function getUpdateUnclaimedHashrateBpsInstructionDataDecoder() {
|
|
10956
|
+
return (0, import_kit83.getStructDecoder)([
|
|
10957
|
+
["discriminator", (0, import_kit83.fixDecoderSize)((0, import_kit83.getBytesDecoder)(), 8)],
|
|
10958
|
+
["newUnclaimedHashrateBps", (0, import_kit83.getU32Decoder)()]
|
|
10959
|
+
]);
|
|
10960
|
+
}
|
|
10961
|
+
function getUpdateUnclaimedHashrateBpsInstructionDataCodec() {
|
|
10962
|
+
return (0, import_kit83.combineCodec)(
|
|
10846
10963
|
getUpdateUnclaimedHashrateBpsInstructionDataEncoder(),
|
|
10847
10964
|
getUpdateUnclaimedHashrateBpsInstructionDataDecoder()
|
|
10848
10965
|
);
|
|
@@ -10858,7 +10975,7 @@ async function getUpdateUnclaimedHashrateBpsInstructionAsync(input, config) {
|
|
|
10858
10975
|
if (!accounts.satrushConfig.value) {
|
|
10859
10976
|
accounts.satrushConfig.value = await findSatrushConfigPda();
|
|
10860
10977
|
}
|
|
10861
|
-
const getAccountMeta = (0,
|
|
10978
|
+
const getAccountMeta = (0, import_program_client_core39.getAccountMetaFactory)(programAddress, "programId");
|
|
10862
10979
|
return Object.freeze({
|
|
10863
10980
|
accounts: [
|
|
10864
10981
|
getAccountMeta("authority", accounts.authority),
|
|
@@ -10878,7 +10995,7 @@ function getUpdateUnclaimedHashrateBpsInstruction(input, config) {
|
|
|
10878
10995
|
};
|
|
10879
10996
|
const accounts = originalAccounts;
|
|
10880
10997
|
const args = { ...input };
|
|
10881
|
-
const getAccountMeta = (0,
|
|
10998
|
+
const getAccountMeta = (0, import_program_client_core39.getAccountMetaFactory)(programAddress, "programId");
|
|
10882
10999
|
return Object.freeze({
|
|
10883
11000
|
accounts: [
|
|
10884
11001
|
getAccountMeta("authority", accounts.authority),
|
|
@@ -10892,8 +11009,8 @@ function getUpdateUnclaimedHashrateBpsInstruction(input, config) {
|
|
|
10892
11009
|
}
|
|
10893
11010
|
function parseUpdateUnclaimedHashrateBpsInstruction(instruction) {
|
|
10894
11011
|
if (instruction.accounts.length < 2) {
|
|
10895
|
-
throw new
|
|
10896
|
-
|
|
11012
|
+
throw new import_kit83.SolanaError(
|
|
11013
|
+
import_kit83.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
|
|
10897
11014
|
{
|
|
10898
11015
|
actualAccountMetas: instruction.accounts.length,
|
|
10899
11016
|
expectedAccountMetas: 2
|
|
@@ -10916,27 +11033,27 @@ function parseUpdateUnclaimedHashrateBpsInstruction(instruction) {
|
|
|
10916
11033
|
}
|
|
10917
11034
|
|
|
10918
11035
|
// src/generated/instructions/withdrawProtocolFees.ts
|
|
10919
|
-
var
|
|
10920
|
-
var
|
|
11036
|
+
var import_kit84 = require("@solana/kit");
|
|
11037
|
+
var import_program_client_core40 = require("@solana/program-client-core");
|
|
10921
11038
|
var WITHDRAW_PROTOCOL_FEES_DISCRIMINATOR = new Uint8Array([11, 68, 165, 98, 18, 208, 134, 73]);
|
|
10922
11039
|
function getWithdrawProtocolFeesDiscriminatorBytes() {
|
|
10923
|
-
return (0,
|
|
11040
|
+
return (0, import_kit84.fixEncoderSize)((0, import_kit84.getBytesEncoder)(), 8).encode(
|
|
10924
11041
|
WITHDRAW_PROTOCOL_FEES_DISCRIMINATOR
|
|
10925
11042
|
);
|
|
10926
11043
|
}
|
|
10927
11044
|
function getWithdrawProtocolFeesInstructionDataEncoder() {
|
|
10928
|
-
return (0,
|
|
10929
|
-
(0,
|
|
11045
|
+
return (0, import_kit84.transformEncoder)(
|
|
11046
|
+
(0, import_kit84.getStructEncoder)([["discriminator", (0, import_kit84.fixEncoderSize)((0, import_kit84.getBytesEncoder)(), 8)]]),
|
|
10930
11047
|
(value) => ({ ...value, discriminator: WITHDRAW_PROTOCOL_FEES_DISCRIMINATOR })
|
|
10931
11048
|
);
|
|
10932
11049
|
}
|
|
10933
11050
|
function getWithdrawProtocolFeesInstructionDataDecoder() {
|
|
10934
|
-
return (0,
|
|
10935
|
-
["discriminator", (0,
|
|
11051
|
+
return (0, import_kit84.getStructDecoder)([
|
|
11052
|
+
["discriminator", (0, import_kit84.fixDecoderSize)((0, import_kit84.getBytesDecoder)(), 8)]
|
|
10936
11053
|
]);
|
|
10937
11054
|
}
|
|
10938
11055
|
function getWithdrawProtocolFeesInstructionDataCodec() {
|
|
10939
|
-
return (0,
|
|
11056
|
+
return (0, import_kit84.combineCodec)(
|
|
10940
11057
|
getWithdrawProtocolFeesInstructionDataEncoder(),
|
|
10941
11058
|
getWithdrawProtocolFeesInstructionDataDecoder()
|
|
10942
11059
|
);
|
|
@@ -10975,16 +11092,16 @@ async function getWithdrawProtocolFeesInstructionAsync(input, config) {
|
|
|
10975
11092
|
accounts.treasury.value = await findTreasuryPda();
|
|
10976
11093
|
}
|
|
10977
11094
|
if (!accounts.treasuryUsdAta.value) {
|
|
10978
|
-
accounts.treasuryUsdAta.value = await (0,
|
|
11095
|
+
accounts.treasuryUsdAta.value = await (0, import_kit84.getProgramDerivedAddress)({
|
|
10979
11096
|
programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
|
|
10980
11097
|
seeds: [
|
|
10981
|
-
(0,
|
|
10982
|
-
(0,
|
|
11098
|
+
(0, import_kit84.getAddressEncoder)().encode(
|
|
11099
|
+
(0, import_program_client_core40.getAddressFromResolvedInstructionAccount)(
|
|
10983
11100
|
"treasury",
|
|
10984
11101
|
accounts.treasury.value
|
|
10985
11102
|
)
|
|
10986
11103
|
),
|
|
10987
|
-
(0,
|
|
11104
|
+
(0, import_kit84.getBytesEncoder)().encode(
|
|
10988
11105
|
new Uint8Array([
|
|
10989
11106
|
6,
|
|
10990
11107
|
221,
|
|
@@ -11020,8 +11137,8 @@ async function getWithdrawProtocolFeesInstructionAsync(input, config) {
|
|
|
11020
11137
|
169
|
|
11021
11138
|
])
|
|
11022
11139
|
),
|
|
11023
|
-
(0,
|
|
11024
|
-
(0,
|
|
11140
|
+
(0, import_kit84.getAddressEncoder)().encode(
|
|
11141
|
+
(0, import_program_client_core40.getAddressFromResolvedInstructionAccount)(
|
|
11025
11142
|
"usdMint",
|
|
11026
11143
|
accounts.usdMint.value
|
|
11027
11144
|
)
|
|
@@ -11030,16 +11147,16 @@ async function getWithdrawProtocolFeesInstructionAsync(input, config) {
|
|
|
11030
11147
|
});
|
|
11031
11148
|
}
|
|
11032
11149
|
if (!accounts.treasuryBtcAta.value) {
|
|
11033
|
-
accounts.treasuryBtcAta.value = await (0,
|
|
11150
|
+
accounts.treasuryBtcAta.value = await (0, import_kit84.getProgramDerivedAddress)({
|
|
11034
11151
|
programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
|
|
11035
11152
|
seeds: [
|
|
11036
|
-
(0,
|
|
11037
|
-
(0,
|
|
11153
|
+
(0, import_kit84.getAddressEncoder)().encode(
|
|
11154
|
+
(0, import_program_client_core40.getAddressFromResolvedInstructionAccount)(
|
|
11038
11155
|
"treasury",
|
|
11039
11156
|
accounts.treasury.value
|
|
11040
11157
|
)
|
|
11041
11158
|
),
|
|
11042
|
-
(0,
|
|
11159
|
+
(0, import_kit84.getBytesEncoder)().encode(
|
|
11043
11160
|
new Uint8Array([
|
|
11044
11161
|
6,
|
|
11045
11162
|
221,
|
|
@@ -11075,8 +11192,8 @@ async function getWithdrawProtocolFeesInstructionAsync(input, config) {
|
|
|
11075
11192
|
169
|
|
11076
11193
|
])
|
|
11077
11194
|
),
|
|
11078
|
-
(0,
|
|
11079
|
-
(0,
|
|
11195
|
+
(0, import_kit84.getAddressEncoder)().encode(
|
|
11196
|
+
(0, import_program_client_core40.getAddressFromResolvedInstructionAccount)(
|
|
11080
11197
|
"btcMint",
|
|
11081
11198
|
accounts.btcMint.value
|
|
11082
11199
|
)
|
|
@@ -11085,16 +11202,16 @@ async function getWithdrawProtocolFeesInstructionAsync(input, config) {
|
|
|
11085
11202
|
});
|
|
11086
11203
|
}
|
|
11087
11204
|
if (!accounts.feeRecipientUsdAta.value) {
|
|
11088
|
-
accounts.feeRecipientUsdAta.value = await (0,
|
|
11205
|
+
accounts.feeRecipientUsdAta.value = await (0, import_kit84.getProgramDerivedAddress)({
|
|
11089
11206
|
programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
|
|
11090
11207
|
seeds: [
|
|
11091
|
-
(0,
|
|
11092
|
-
(0,
|
|
11208
|
+
(0, import_kit84.getAddressEncoder)().encode(
|
|
11209
|
+
(0, import_program_client_core40.getAddressFromResolvedInstructionAccount)(
|
|
11093
11210
|
"feeRecipient",
|
|
11094
11211
|
accounts.feeRecipient.value
|
|
11095
11212
|
)
|
|
11096
11213
|
),
|
|
11097
|
-
(0,
|
|
11214
|
+
(0, import_kit84.getBytesEncoder)().encode(
|
|
11098
11215
|
new Uint8Array([
|
|
11099
11216
|
6,
|
|
11100
11217
|
221,
|
|
@@ -11130,8 +11247,8 @@ async function getWithdrawProtocolFeesInstructionAsync(input, config) {
|
|
|
11130
11247
|
169
|
|
11131
11248
|
])
|
|
11132
11249
|
),
|
|
11133
|
-
(0,
|
|
11134
|
-
(0,
|
|
11250
|
+
(0, import_kit84.getAddressEncoder)().encode(
|
|
11251
|
+
(0, import_program_client_core40.getAddressFromResolvedInstructionAccount)(
|
|
11135
11252
|
"usdMint",
|
|
11136
11253
|
accounts.usdMint.value
|
|
11137
11254
|
)
|
|
@@ -11140,16 +11257,16 @@ async function getWithdrawProtocolFeesInstructionAsync(input, config) {
|
|
|
11140
11257
|
});
|
|
11141
11258
|
}
|
|
11142
11259
|
if (!accounts.feeRecipientBtcAta.value) {
|
|
11143
|
-
accounts.feeRecipientBtcAta.value = await (0,
|
|
11260
|
+
accounts.feeRecipientBtcAta.value = await (0, import_kit84.getProgramDerivedAddress)({
|
|
11144
11261
|
programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
|
|
11145
11262
|
seeds: [
|
|
11146
|
-
(0,
|
|
11147
|
-
(0,
|
|
11263
|
+
(0, import_kit84.getAddressEncoder)().encode(
|
|
11264
|
+
(0, import_program_client_core40.getAddressFromResolvedInstructionAccount)(
|
|
11148
11265
|
"feeRecipient",
|
|
11149
11266
|
accounts.feeRecipient.value
|
|
11150
11267
|
)
|
|
11151
11268
|
),
|
|
11152
|
-
(0,
|
|
11269
|
+
(0, import_kit84.getBytesEncoder)().encode(
|
|
11153
11270
|
new Uint8Array([
|
|
11154
11271
|
6,
|
|
11155
11272
|
221,
|
|
@@ -11185,8 +11302,8 @@ async function getWithdrawProtocolFeesInstructionAsync(input, config) {
|
|
|
11185
11302
|
169
|
|
11186
11303
|
])
|
|
11187
11304
|
),
|
|
11188
|
-
(0,
|
|
11189
|
-
(0,
|
|
11305
|
+
(0, import_kit84.getAddressEncoder)().encode(
|
|
11306
|
+
(0, import_program_client_core40.getAddressFromResolvedInstructionAccount)(
|
|
11190
11307
|
"btcMint",
|
|
11191
11308
|
accounts.btcMint.value
|
|
11192
11309
|
)
|
|
@@ -11203,7 +11320,7 @@ async function getWithdrawProtocolFeesInstructionAsync(input, config) {
|
|
|
11203
11320
|
if (!accounts.systemProgram.value) {
|
|
11204
11321
|
accounts.systemProgram.value = "11111111111111111111111111111111";
|
|
11205
11322
|
}
|
|
11206
|
-
const getAccountMeta = (0,
|
|
11323
|
+
const getAccountMeta = (0, import_program_client_core40.getAccountMetaFactory)(programAddress, "programId");
|
|
11207
11324
|
return Object.freeze({
|
|
11208
11325
|
accounts: [
|
|
11209
11326
|
getAccountMeta("authority", accounts.authority),
|
|
@@ -11260,7 +11377,7 @@ function getWithdrawProtocolFeesInstruction(input, config) {
|
|
|
11260
11377
|
if (!accounts.systemProgram.value) {
|
|
11261
11378
|
accounts.systemProgram.value = "11111111111111111111111111111111";
|
|
11262
11379
|
}
|
|
11263
|
-
const getAccountMeta = (0,
|
|
11380
|
+
const getAccountMeta = (0, import_program_client_core40.getAccountMetaFactory)(programAddress, "programId");
|
|
11264
11381
|
return Object.freeze({
|
|
11265
11382
|
accounts: [
|
|
11266
11383
|
getAccountMeta("authority", accounts.authority),
|
|
@@ -11283,8 +11400,8 @@ function getWithdrawProtocolFeesInstruction(input, config) {
|
|
|
11283
11400
|
}
|
|
11284
11401
|
function parseWithdrawProtocolFeesInstruction(instruction) {
|
|
11285
11402
|
if (instruction.accounts.length < 13) {
|
|
11286
|
-
throw new
|
|
11287
|
-
|
|
11403
|
+
throw new import_kit84.SolanaError(
|
|
11404
|
+
import_kit84.SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
|
|
11288
11405
|
{
|
|
11289
11406
|
actualAccountMetas: instruction.accounts.length,
|
|
11290
11407
|
expectedAccountMetas: 13
|
|
@@ -11342,143 +11459,143 @@ var SatrushAccount = /* @__PURE__ */ ((SatrushAccount2) => {
|
|
|
11342
11459
|
})(SatrushAccount || {});
|
|
11343
11460
|
function identifySatrushAccount(account) {
|
|
11344
11461
|
const data = "data" in account ? account.data : account;
|
|
11345
|
-
if ((0,
|
|
11462
|
+
if ((0, import_kit85.containsBytes)(
|
|
11346
11463
|
data,
|
|
11347
|
-
(0,
|
|
11464
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11348
11465
|
new Uint8Array([79, 48, 160, 63, 153, 132, 240, 56])
|
|
11349
11466
|
),
|
|
11350
11467
|
0
|
|
11351
11468
|
)) {
|
|
11352
11469
|
return 0 /* Board */;
|
|
11353
11470
|
}
|
|
11354
|
-
if ((0,
|
|
11471
|
+
if ((0, import_kit85.containsBytes)(
|
|
11355
11472
|
data,
|
|
11356
|
-
(0,
|
|
11473
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11357
11474
|
new Uint8Array([100, 209, 6, 66, 115, 53, 132, 9])
|
|
11358
11475
|
),
|
|
11359
11476
|
0
|
|
11360
11477
|
)) {
|
|
11361
11478
|
return 1 /* EpochVault */;
|
|
11362
11479
|
}
|
|
11363
|
-
if ((0,
|
|
11480
|
+
if ((0, import_kit85.containsBytes)(
|
|
11364
11481
|
data,
|
|
11365
|
-
(0,
|
|
11482
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11366
11483
|
new Uint8Array([75, 243, 246, 41, 173, 130, 196, 91])
|
|
11367
11484
|
),
|
|
11368
11485
|
0
|
|
11369
11486
|
)) {
|
|
11370
11487
|
return 2 /* EpochVaultEntry */;
|
|
11371
11488
|
}
|
|
11372
|
-
if ((0,
|
|
11489
|
+
if ((0, import_kit85.containsBytes)(
|
|
11373
11490
|
data,
|
|
11374
|
-
(0,
|
|
11491
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11375
11492
|
new Uint8Array([116, 108, 198, 176, 193, 190, 91, 125])
|
|
11376
11493
|
),
|
|
11377
11494
|
0
|
|
11378
11495
|
)) {
|
|
11379
11496
|
return 3 /* EpochVaultIteration */;
|
|
11380
11497
|
}
|
|
11381
|
-
if ((0,
|
|
11498
|
+
if ((0, import_kit85.containsBytes)(
|
|
11382
11499
|
data,
|
|
11383
|
-
(0,
|
|
11500
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11384
11501
|
new Uint8Array([121, 238, 146, 107, 234, 24, 227, 31])
|
|
11385
11502
|
),
|
|
11386
11503
|
0
|
|
11387
11504
|
)) {
|
|
11388
11505
|
return 4 /* EpochVaultPage */;
|
|
11389
11506
|
}
|
|
11390
|
-
if ((0,
|
|
11507
|
+
if ((0, import_kit85.containsBytes)(
|
|
11391
11508
|
data,
|
|
11392
|
-
(0,
|
|
11509
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11393
11510
|
new Uint8Array([223, 113, 15, 54, 123, 122, 140, 100])
|
|
11394
11511
|
),
|
|
11395
11512
|
0
|
|
11396
11513
|
)) {
|
|
11397
11514
|
return 5 /* Miner */;
|
|
11398
11515
|
}
|
|
11399
|
-
if ((0,
|
|
11516
|
+
if ((0, import_kit85.containsBytes)(
|
|
11400
11517
|
data,
|
|
11401
|
-
(0,
|
|
11518
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11402
11519
|
new Uint8Array([134, 90, 53, 34, 240, 221, 175, 212])
|
|
11403
11520
|
),
|
|
11404
11521
|
0
|
|
11405
11522
|
)) {
|
|
11406
11523
|
return 6 /* OneBtcVault */;
|
|
11407
11524
|
}
|
|
11408
|
-
if ((0,
|
|
11525
|
+
if ((0, import_kit85.containsBytes)(
|
|
11409
11526
|
data,
|
|
11410
|
-
(0,
|
|
11527
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11411
11528
|
new Uint8Array([255, 64, 185, 130, 97, 37, 230, 219])
|
|
11412
11529
|
),
|
|
11413
11530
|
0
|
|
11414
11531
|
)) {
|
|
11415
11532
|
return 7 /* OneBtcVaultEntry */;
|
|
11416
11533
|
}
|
|
11417
|
-
if ((0,
|
|
11534
|
+
if ((0, import_kit85.containsBytes)(
|
|
11418
11535
|
data,
|
|
11419
|
-
(0,
|
|
11536
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11420
11537
|
new Uint8Array([190, 205, 75, 222, 220, 249, 43, 126])
|
|
11421
11538
|
),
|
|
11422
11539
|
0
|
|
11423
11540
|
)) {
|
|
11424
11541
|
return 8 /* OneBtcVaultIteration */;
|
|
11425
11542
|
}
|
|
11426
|
-
if ((0,
|
|
11543
|
+
if ((0, import_kit85.containsBytes)(
|
|
11427
11544
|
data,
|
|
11428
|
-
(0,
|
|
11545
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11429
11546
|
new Uint8Array([16, 128, 211, 70, 213, 109, 108, 216])
|
|
11430
11547
|
),
|
|
11431
11548
|
0
|
|
11432
11549
|
)) {
|
|
11433
11550
|
return 9 /* PublicAutomation */;
|
|
11434
11551
|
}
|
|
11435
|
-
if ((0,
|
|
11552
|
+
if ((0, import_kit85.containsBytes)(
|
|
11436
11553
|
data,
|
|
11437
|
-
(0,
|
|
11554
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11438
11555
|
new Uint8Array([209, 64, 180, 169, 40, 181, 110, 236])
|
|
11439
11556
|
),
|
|
11440
11557
|
0
|
|
11441
11558
|
)) {
|
|
11442
11559
|
return 10 /* PublicDeployment */;
|
|
11443
11560
|
}
|
|
11444
|
-
if ((0,
|
|
11561
|
+
if ((0, import_kit85.containsBytes)(
|
|
11445
11562
|
data,
|
|
11446
|
-
(0,
|
|
11563
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11447
11564
|
new Uint8Array([87, 127, 165, 51, 73, 78, 116, 174])
|
|
11448
11565
|
),
|
|
11449
11566
|
0
|
|
11450
11567
|
)) {
|
|
11451
11568
|
return 11 /* Round */;
|
|
11452
11569
|
}
|
|
11453
|
-
if ((0,
|
|
11570
|
+
if ((0, import_kit85.containsBytes)(
|
|
11454
11571
|
data,
|
|
11455
|
-
(0,
|
|
11572
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11456
11573
|
new Uint8Array([113, 169, 164, 118, 148, 217, 160, 200])
|
|
11457
11574
|
),
|
|
11458
11575
|
0
|
|
11459
11576
|
)) {
|
|
11460
11577
|
return 12 /* SatrushConfig */;
|
|
11461
11578
|
}
|
|
11462
|
-
if ((0,
|
|
11579
|
+
if ((0, import_kit85.containsBytes)(
|
|
11463
11580
|
data,
|
|
11464
|
-
(0,
|
|
11581
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11465
11582
|
new Uint8Array([97, 10, 251, 68, 215, 103, 124, 183])
|
|
11466
11583
|
),
|
|
11467
11584
|
0
|
|
11468
11585
|
)) {
|
|
11469
11586
|
return 13 /* SatsVault */;
|
|
11470
11587
|
}
|
|
11471
|
-
if ((0,
|
|
11588
|
+
if ((0, import_kit85.containsBytes)(
|
|
11472
11589
|
data,
|
|
11473
|
-
(0,
|
|
11590
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11474
11591
|
new Uint8Array([238, 239, 123, 238, 89, 1, 168, 253])
|
|
11475
11592
|
),
|
|
11476
11593
|
0
|
|
11477
11594
|
)) {
|
|
11478
11595
|
return 14 /* Treasury */;
|
|
11479
11596
|
}
|
|
11480
|
-
throw new
|
|
11481
|
-
|
|
11597
|
+
throw new import_kit85.SolanaError(
|
|
11598
|
+
import_kit85.SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT,
|
|
11482
11599
|
{ accountData: data, programName: "satrush" }
|
|
11483
11600
|
);
|
|
11484
11601
|
}
|
|
@@ -11520,365 +11637,375 @@ var SatrushInstruction = /* @__PURE__ */ ((SatrushInstruction2) => {
|
|
|
11520
11637
|
SatrushInstruction2[SatrushInstruction2["UpdateDeploymentSettleGraceDuration"] = 34] = "UpdateDeploymentSettleGraceDuration";
|
|
11521
11638
|
SatrushInstruction2[SatrushInstruction2["UpdateEpochVaultIterationDuration"] = 35] = "UpdateEpochVaultIterationDuration";
|
|
11522
11639
|
SatrushInstruction2[SatrushInstruction2["UpdateMinDeployUsdAmount"] = 36] = "UpdateMinDeployUsdAmount";
|
|
11523
|
-
SatrushInstruction2[SatrushInstruction2["
|
|
11524
|
-
SatrushInstruction2[SatrushInstruction2["
|
|
11640
|
+
SatrushInstruction2[SatrushInstruction2["UpdateStrikeTriggerModulus"] = 37] = "UpdateStrikeTriggerModulus";
|
|
11641
|
+
SatrushInstruction2[SatrushInstruction2["UpdateUnclaimedHashrateBps"] = 38] = "UpdateUnclaimedHashrateBps";
|
|
11642
|
+
SatrushInstruction2[SatrushInstruction2["WithdrawProtocolFees"] = 39] = "WithdrawProtocolFees";
|
|
11525
11643
|
return SatrushInstruction2;
|
|
11526
11644
|
})(SatrushInstruction || {});
|
|
11527
11645
|
function identifySatrushInstruction(instruction) {
|
|
11528
11646
|
const data = "data" in instruction ? instruction.data : instruction;
|
|
11529
|
-
if ((0,
|
|
11647
|
+
if ((0, import_kit85.containsBytes)(
|
|
11530
11648
|
data,
|
|
11531
|
-
(0,
|
|
11649
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11532
11650
|
new Uint8Array([90, 201, 98, 189, 106, 249, 86, 109])
|
|
11533
11651
|
),
|
|
11534
11652
|
0
|
|
11535
11653
|
)) {
|
|
11536
11654
|
return 0 /* BuyEpochTickets */;
|
|
11537
11655
|
}
|
|
11538
|
-
if ((0,
|
|
11656
|
+
if ((0, import_kit85.containsBytes)(
|
|
11539
11657
|
data,
|
|
11540
|
-
(0,
|
|
11658
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11541
11659
|
new Uint8Array([4, 48, 106, 230, 146, 124, 140, 167])
|
|
11542
11660
|
),
|
|
11543
11661
|
0
|
|
11544
11662
|
)) {
|
|
11545
11663
|
return 1 /* BuyOneBtcTickets */;
|
|
11546
11664
|
}
|
|
11547
|
-
if ((0,
|
|
11665
|
+
if ((0, import_kit85.containsBytes)(
|
|
11548
11666
|
data,
|
|
11549
|
-
(0,
|
|
11667
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11550
11668
|
new Uint8Array([87, 135, 14, 43, 190, 79, 45, 212])
|
|
11551
11669
|
),
|
|
11552
11670
|
0
|
|
11553
11671
|
)) {
|
|
11554
11672
|
return 2 /* CancelPublicAutomation */;
|
|
11555
11673
|
}
|
|
11556
|
-
if ((0,
|
|
11674
|
+
if ((0, import_kit85.containsBytes)(
|
|
11557
11675
|
data,
|
|
11558
|
-
(0,
|
|
11676
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11559
11677
|
new Uint8Array([226, 196, 170, 104, 125, 21, 190, 232])
|
|
11560
11678
|
),
|
|
11561
11679
|
0
|
|
11562
11680
|
)) {
|
|
11563
11681
|
return 3 /* ClaimEpochReward */;
|
|
11564
11682
|
}
|
|
11565
|
-
if ((0,
|
|
11683
|
+
if ((0, import_kit85.containsBytes)(
|
|
11566
11684
|
data,
|
|
11567
|
-
(0,
|
|
11685
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11568
11686
|
new Uint8Array([53, 168, 61, 211, 206, 81, 133, 175])
|
|
11569
11687
|
),
|
|
11570
11688
|
0
|
|
11571
11689
|
)) {
|
|
11572
11690
|
return 4 /* ClaimOneBtcReward */;
|
|
11573
11691
|
}
|
|
11574
|
-
if ((0,
|
|
11692
|
+
if ((0, import_kit85.containsBytes)(
|
|
11575
11693
|
data,
|
|
11576
|
-
(0,
|
|
11694
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11577
11695
|
new Uint8Array([196, 77, 168, 181, 6, 119, 249, 154])
|
|
11578
11696
|
),
|
|
11579
11697
|
0
|
|
11580
11698
|
)) {
|
|
11581
11699
|
return 5 /* ClaimSats */;
|
|
11582
11700
|
}
|
|
11583
|
-
if ((0,
|
|
11701
|
+
if ((0, import_kit85.containsBytes)(
|
|
11584
11702
|
data,
|
|
11585
|
-
(0,
|
|
11703
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11586
11704
|
new Uint8Array([241, 89, 98, 124, 223, 205, 215, 104])
|
|
11587
11705
|
),
|
|
11588
11706
|
0
|
|
11589
11707
|
)) {
|
|
11590
11708
|
return 6 /* ClaimUsd */;
|
|
11591
11709
|
}
|
|
11592
|
-
if ((0,
|
|
11710
|
+
if ((0, import_kit85.containsBytes)(
|
|
11593
11711
|
data,
|
|
11594
|
-
(0,
|
|
11712
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11595
11713
|
new Uint8Array([27, 23, 127, 47, 147, 184, 239, 190])
|
|
11596
11714
|
),
|
|
11597
11715
|
0
|
|
11598
11716
|
)) {
|
|
11599
11717
|
return 7 /* CloseEpochEntry */;
|
|
11600
11718
|
}
|
|
11601
|
-
if ((0,
|
|
11719
|
+
if ((0, import_kit85.containsBytes)(
|
|
11602
11720
|
data,
|
|
11603
|
-
(0,
|
|
11721
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11604
11722
|
new Uint8Array([80, 74, 10, 29, 63, 106, 63, 192])
|
|
11605
11723
|
),
|
|
11606
11724
|
0
|
|
11607
11725
|
)) {
|
|
11608
11726
|
return 8 /* CloseEpochIteration */;
|
|
11609
11727
|
}
|
|
11610
|
-
if ((0,
|
|
11728
|
+
if ((0, import_kit85.containsBytes)(
|
|
11611
11729
|
data,
|
|
11612
|
-
(0,
|
|
11730
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11613
11731
|
new Uint8Array([11, 123, 237, 176, 25, 240, 59, 135])
|
|
11614
11732
|
),
|
|
11615
11733
|
0
|
|
11616
11734
|
)) {
|
|
11617
11735
|
return 9 /* CloseEpochPage */;
|
|
11618
11736
|
}
|
|
11619
|
-
if ((0,
|
|
11737
|
+
if ((0, import_kit85.containsBytes)(
|
|
11620
11738
|
data,
|
|
11621
|
-
(0,
|
|
11739
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11622
11740
|
new Uint8Array([181, 42, 174, 200, 192, 21, 27, 187])
|
|
11623
11741
|
),
|
|
11624
11742
|
0
|
|
11625
11743
|
)) {
|
|
11626
11744
|
return 10 /* CloseOneBtcIteration */;
|
|
11627
11745
|
}
|
|
11628
|
-
if ((0,
|
|
11746
|
+
if ((0, import_kit85.containsBytes)(
|
|
11629
11747
|
data,
|
|
11630
|
-
(0,
|
|
11748
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11631
11749
|
new Uint8Array([251, 62, 143, 106, 218, 1, 162, 181])
|
|
11632
11750
|
),
|
|
11633
11751
|
0
|
|
11634
11752
|
)) {
|
|
11635
11753
|
return 11 /* CloseOneBtcTicket */;
|
|
11636
11754
|
}
|
|
11637
|
-
if ((0,
|
|
11755
|
+
if ((0, import_kit85.containsBytes)(
|
|
11638
11756
|
data,
|
|
11639
|
-
(0,
|
|
11757
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11640
11758
|
new Uint8Array([149, 14, 81, 88, 230, 226, 234, 37])
|
|
11641
11759
|
),
|
|
11642
11760
|
0
|
|
11643
11761
|
)) {
|
|
11644
11762
|
return 12 /* CloseRound */;
|
|
11645
11763
|
}
|
|
11646
|
-
if ((0,
|
|
11764
|
+
if ((0, import_kit85.containsBytes)(
|
|
11647
11765
|
data,
|
|
11648
|
-
(0,
|
|
11766
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11649
11767
|
new Uint8Array([81, 129, 130, 38, 99, 204, 224, 177])
|
|
11650
11768
|
),
|
|
11651
11769
|
0
|
|
11652
11770
|
)) {
|
|
11653
11771
|
return 13 /* CreateBoard */;
|
|
11654
11772
|
}
|
|
11655
|
-
if ((0,
|
|
11773
|
+
if ((0, import_kit85.containsBytes)(
|
|
11656
11774
|
data,
|
|
11657
|
-
(0,
|
|
11775
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11658
11776
|
new Uint8Array([69, 146, 29, 218, 228, 29, 229, 241])
|
|
11659
11777
|
),
|
|
11660
11778
|
0
|
|
11661
11779
|
)) {
|
|
11662
11780
|
return 14 /* CreateEpochVault */;
|
|
11663
11781
|
}
|
|
11664
|
-
if ((0,
|
|
11782
|
+
if ((0, import_kit85.containsBytes)(
|
|
11665
11783
|
data,
|
|
11666
|
-
(0,
|
|
11784
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11667
11785
|
new Uint8Array([156, 160, 69, 94, 108, 6, 145, 211])
|
|
11668
11786
|
),
|
|
11669
11787
|
0
|
|
11670
11788
|
)) {
|
|
11671
11789
|
return 15 /* CreateOneBtcVault */;
|
|
11672
11790
|
}
|
|
11673
|
-
if ((0,
|
|
11791
|
+
if ((0, import_kit85.containsBytes)(
|
|
11674
11792
|
data,
|
|
11675
|
-
(0,
|
|
11793
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11676
11794
|
new Uint8Array([195, 44, 245, 180, 58, 206, 203, 229])
|
|
11677
11795
|
),
|
|
11678
11796
|
0
|
|
11679
11797
|
)) {
|
|
11680
11798
|
return 16 /* CreatePublicAutomation */;
|
|
11681
11799
|
}
|
|
11682
|
-
if ((0,
|
|
11800
|
+
if ((0, import_kit85.containsBytes)(
|
|
11683
11801
|
data,
|
|
11684
|
-
(0,
|
|
11802
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11685
11803
|
new Uint8Array([96, 175, 39, 171, 158, 44, 117, 18])
|
|
11686
11804
|
),
|
|
11687
11805
|
0
|
|
11688
11806
|
)) {
|
|
11689
11807
|
return 17 /* CreateSatrushConfig */;
|
|
11690
11808
|
}
|
|
11691
|
-
if ((0,
|
|
11809
|
+
if ((0, import_kit85.containsBytes)(
|
|
11692
11810
|
data,
|
|
11693
|
-
(0,
|
|
11811
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11694
11812
|
new Uint8Array([159, 29, 126, 216, 29, 240, 141, 61])
|
|
11695
11813
|
),
|
|
11696
11814
|
0
|
|
11697
11815
|
)) {
|
|
11698
11816
|
return 18 /* CreateSatsVault */;
|
|
11699
11817
|
}
|
|
11700
|
-
if ((0,
|
|
11818
|
+
if ((0, import_kit85.containsBytes)(
|
|
11701
11819
|
data,
|
|
11702
|
-
(0,
|
|
11820
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11703
11821
|
new Uint8Array([254, 98, 217, 51, 25, 88, 140, 45])
|
|
11704
11822
|
),
|
|
11705
11823
|
0
|
|
11706
11824
|
)) {
|
|
11707
11825
|
return 19 /* CreateTreasury */;
|
|
11708
11826
|
}
|
|
11709
|
-
if ((0,
|
|
11827
|
+
if ((0, import_kit85.containsBytes)(
|
|
11710
11828
|
data,
|
|
11711
|
-
(0,
|
|
11829
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11712
11830
|
new Uint8Array([193, 31, 240, 159, 30, 224, 157, 85])
|
|
11713
11831
|
),
|
|
11714
11832
|
0
|
|
11715
11833
|
)) {
|
|
11716
11834
|
return 20 /* DeployPublic */;
|
|
11717
11835
|
}
|
|
11718
|
-
if ((0,
|
|
11836
|
+
if ((0, import_kit85.containsBytes)(
|
|
11719
11837
|
data,
|
|
11720
|
-
(0,
|
|
11838
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11721
11839
|
new Uint8Array([212, 191, 100, 136, 18, 213, 42, 72])
|
|
11722
11840
|
),
|
|
11723
11841
|
0
|
|
11724
11842
|
)) {
|
|
11725
11843
|
return 21 /* ExecutePublicAutomation */;
|
|
11726
11844
|
}
|
|
11727
|
-
if ((0,
|
|
11845
|
+
if ((0, import_kit85.containsBytes)(
|
|
11728
11846
|
data,
|
|
11729
|
-
(0,
|
|
11847
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11730
11848
|
new Uint8Array([3, 245, 202, 88, 161, 29, 51, 141])
|
|
11731
11849
|
),
|
|
11732
11850
|
0
|
|
11733
11851
|
)) {
|
|
11734
11852
|
return 22 /* RotateRound */;
|
|
11735
11853
|
}
|
|
11736
|
-
if ((0,
|
|
11854
|
+
if ((0, import_kit85.containsBytes)(
|
|
11737
11855
|
data,
|
|
11738
|
-
(0,
|
|
11856
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11739
11857
|
new Uint8Array([89, 228, 101, 114, 103, 98, 126, 229])
|
|
11740
11858
|
),
|
|
11741
11859
|
0
|
|
11742
11860
|
)) {
|
|
11743
11861
|
return 23 /* SealEpochPage */;
|
|
11744
11862
|
}
|
|
11745
|
-
if ((0,
|
|
11863
|
+
if ((0, import_kit85.containsBytes)(
|
|
11746
11864
|
data,
|
|
11747
|
-
(0,
|
|
11865
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11748
11866
|
new Uint8Array([222, 36, 211, 175, 4, 220, 2, 251])
|
|
11749
11867
|
),
|
|
11750
11868
|
0
|
|
11751
11869
|
)) {
|
|
11752
11870
|
return 24 /* SelectEpochWinner */;
|
|
11753
11871
|
}
|
|
11754
|
-
if ((0,
|
|
11872
|
+
if ((0, import_kit85.containsBytes)(
|
|
11755
11873
|
data,
|
|
11756
|
-
(0,
|
|
11874
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11757
11875
|
new Uint8Array([249, 111, 122, 103, 93, 86, 76, 198])
|
|
11758
11876
|
),
|
|
11759
11877
|
0
|
|
11760
11878
|
)) {
|
|
11761
11879
|
return 25 /* SettleDeployPublic */;
|
|
11762
11880
|
}
|
|
11763
|
-
if ((0,
|
|
11881
|
+
if ((0, import_kit85.containsBytes)(
|
|
11764
11882
|
data,
|
|
11765
|
-
(0,
|
|
11883
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11766
11884
|
new Uint8Array([82, 124, 95, 215, 213, 107, 134, 122])
|
|
11767
11885
|
),
|
|
11768
11886
|
0
|
|
11769
11887
|
)) {
|
|
11770
11888
|
return 26 /* SwapEpochStake */;
|
|
11771
11889
|
}
|
|
11772
|
-
if ((0,
|
|
11890
|
+
if ((0, import_kit85.containsBytes)(
|
|
11773
11891
|
data,
|
|
11774
|
-
(0,
|
|
11892
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11775
11893
|
new Uint8Array([61, 147, 13, 247, 164, 34, 14, 57])
|
|
11776
11894
|
),
|
|
11777
11895
|
0
|
|
11778
11896
|
)) {
|
|
11779
11897
|
return 27 /* SwapOneBtcStake */;
|
|
11780
11898
|
}
|
|
11781
|
-
if ((0,
|
|
11899
|
+
if ((0, import_kit85.containsBytes)(
|
|
11782
11900
|
data,
|
|
11783
|
-
(0,
|
|
11901
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11784
11902
|
new Uint8Array([86, 168, 42, 98, 2, 164, 250, 185])
|
|
11785
11903
|
),
|
|
11786
11904
|
0
|
|
11787
11905
|
)) {
|
|
11788
11906
|
return 28 /* SwapRoundStake */;
|
|
11789
11907
|
}
|
|
11790
|
-
if ((0,
|
|
11908
|
+
if ((0, import_kit85.containsBytes)(
|
|
11791
11909
|
data,
|
|
11792
|
-
(0,
|
|
11910
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11793
11911
|
new Uint8Array([129, 112, 9, 43, 91, 154, 157, 135])
|
|
11794
11912
|
),
|
|
11795
11913
|
0
|
|
11796
11914
|
)) {
|
|
11797
11915
|
return 29 /* SwapStrikeStake */;
|
|
11798
11916
|
}
|
|
11799
|
-
if ((0,
|
|
11917
|
+
if ((0, import_kit85.containsBytes)(
|
|
11800
11918
|
data,
|
|
11801
|
-
(0,
|
|
11919
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11802
11920
|
new Uint8Array([1, 96, 199, 199, 107, 118, 193, 87])
|
|
11803
11921
|
),
|
|
11804
11922
|
0
|
|
11805
11923
|
)) {
|
|
11806
11924
|
return 30 /* TopUpPublicAutomation */;
|
|
11807
11925
|
}
|
|
11808
|
-
if ((0,
|
|
11926
|
+
if ((0, import_kit85.containsBytes)(
|
|
11809
11927
|
data,
|
|
11810
|
-
(0,
|
|
11928
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11811
11929
|
new Uint8Array([93, 12, 139, 55, 235, 88, 37, 117])
|
|
11812
11930
|
),
|
|
11813
11931
|
0
|
|
11814
11932
|
)) {
|
|
11815
11933
|
return 31 /* TriggerEpochDraw */;
|
|
11816
11934
|
}
|
|
11817
|
-
if ((0,
|
|
11935
|
+
if ((0, import_kit85.containsBytes)(
|
|
11818
11936
|
data,
|
|
11819
|
-
(0,
|
|
11937
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11820
11938
|
new Uint8Array([252, 210, 238, 28, 169, 118, 28, 11])
|
|
11821
11939
|
),
|
|
11822
11940
|
0
|
|
11823
11941
|
)) {
|
|
11824
11942
|
return 32 /* TriggerOneBtcDraw */;
|
|
11825
11943
|
}
|
|
11826
|
-
if ((0,
|
|
11944
|
+
if ((0, import_kit85.containsBytes)(
|
|
11827
11945
|
data,
|
|
11828
|
-
(0,
|
|
11946
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11829
11947
|
new Uint8Array([12, 130, 188, 85, 167, 187, 204, 183])
|
|
11830
11948
|
),
|
|
11831
11949
|
0
|
|
11832
11950
|
)) {
|
|
11833
11951
|
return 33 /* UpdateBoardRoundDuration */;
|
|
11834
11952
|
}
|
|
11835
|
-
if ((0,
|
|
11953
|
+
if ((0, import_kit85.containsBytes)(
|
|
11836
11954
|
data,
|
|
11837
|
-
(0,
|
|
11955
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11838
11956
|
new Uint8Array([2, 212, 246, 89, 139, 64, 104, 74])
|
|
11839
11957
|
),
|
|
11840
11958
|
0
|
|
11841
11959
|
)) {
|
|
11842
11960
|
return 34 /* UpdateDeploymentSettleGraceDuration */;
|
|
11843
11961
|
}
|
|
11844
|
-
if ((0,
|
|
11962
|
+
if ((0, import_kit85.containsBytes)(
|
|
11845
11963
|
data,
|
|
11846
|
-
(0,
|
|
11964
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11847
11965
|
new Uint8Array([171, 103, 59, 229, 174, 188, 210, 121])
|
|
11848
11966
|
),
|
|
11849
11967
|
0
|
|
11850
11968
|
)) {
|
|
11851
11969
|
return 35 /* UpdateEpochVaultIterationDuration */;
|
|
11852
11970
|
}
|
|
11853
|
-
if ((0,
|
|
11971
|
+
if ((0, import_kit85.containsBytes)(
|
|
11854
11972
|
data,
|
|
11855
|
-
(0,
|
|
11973
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11856
11974
|
new Uint8Array([187, 108, 89, 178, 249, 101, 187, 33])
|
|
11857
11975
|
),
|
|
11858
11976
|
0
|
|
11859
11977
|
)) {
|
|
11860
11978
|
return 36 /* UpdateMinDeployUsdAmount */;
|
|
11861
11979
|
}
|
|
11862
|
-
if ((0,
|
|
11980
|
+
if ((0, import_kit85.containsBytes)(
|
|
11981
|
+
data,
|
|
11982
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11983
|
+
new Uint8Array([241, 172, 229, 62, 191, 163, 60, 186])
|
|
11984
|
+
),
|
|
11985
|
+
0
|
|
11986
|
+
)) {
|
|
11987
|
+
return 37 /* UpdateStrikeTriggerModulus */;
|
|
11988
|
+
}
|
|
11989
|
+
if ((0, import_kit85.containsBytes)(
|
|
11863
11990
|
data,
|
|
11864
|
-
(0,
|
|
11991
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11865
11992
|
new Uint8Array([237, 38, 26, 14, 73, 161, 208, 157])
|
|
11866
11993
|
),
|
|
11867
11994
|
0
|
|
11868
11995
|
)) {
|
|
11869
|
-
return
|
|
11996
|
+
return 38 /* UpdateUnclaimedHashrateBps */;
|
|
11870
11997
|
}
|
|
11871
|
-
if ((0,
|
|
11998
|
+
if ((0, import_kit85.containsBytes)(
|
|
11872
11999
|
data,
|
|
11873
|
-
(0,
|
|
12000
|
+
(0, import_kit85.fixEncoderSize)((0, import_kit85.getBytesEncoder)(), 8).encode(
|
|
11874
12001
|
new Uint8Array([11, 68, 165, 98, 18, 208, 134, 73])
|
|
11875
12002
|
),
|
|
11876
12003
|
0
|
|
11877
12004
|
)) {
|
|
11878
|
-
return
|
|
12005
|
+
return 39 /* WithdrawProtocolFees */;
|
|
11879
12006
|
}
|
|
11880
|
-
throw new
|
|
11881
|
-
|
|
12007
|
+
throw new import_kit85.SolanaError(
|
|
12008
|
+
import_kit85.SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
|
|
11882
12009
|
{ instructionData: data, programName: "satrush" }
|
|
11883
12010
|
);
|
|
11884
12011
|
}
|
|
@@ -11886,481 +12013,492 @@ function parseSatrushInstruction(instruction) {
|
|
|
11886
12013
|
const instructionType = identifySatrushInstruction(instruction);
|
|
11887
12014
|
switch (instructionType) {
|
|
11888
12015
|
case 0 /* BuyEpochTickets */: {
|
|
11889
|
-
(0,
|
|
12016
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
11890
12017
|
return {
|
|
11891
12018
|
instructionType: 0 /* BuyEpochTickets */,
|
|
11892
12019
|
...parseBuyEpochTicketsInstruction(instruction)
|
|
11893
12020
|
};
|
|
11894
12021
|
}
|
|
11895
12022
|
case 1 /* BuyOneBtcTickets */: {
|
|
11896
|
-
(0,
|
|
12023
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
11897
12024
|
return {
|
|
11898
12025
|
instructionType: 1 /* BuyOneBtcTickets */,
|
|
11899
12026
|
...parseBuyOneBtcTicketsInstruction(instruction)
|
|
11900
12027
|
};
|
|
11901
12028
|
}
|
|
11902
12029
|
case 2 /* CancelPublicAutomation */: {
|
|
11903
|
-
(0,
|
|
12030
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
11904
12031
|
return {
|
|
11905
12032
|
instructionType: 2 /* CancelPublicAutomation */,
|
|
11906
12033
|
...parseCancelPublicAutomationInstruction(instruction)
|
|
11907
12034
|
};
|
|
11908
12035
|
}
|
|
11909
12036
|
case 3 /* ClaimEpochReward */: {
|
|
11910
|
-
(0,
|
|
12037
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
11911
12038
|
return {
|
|
11912
12039
|
instructionType: 3 /* ClaimEpochReward */,
|
|
11913
12040
|
...parseClaimEpochRewardInstruction(instruction)
|
|
11914
12041
|
};
|
|
11915
12042
|
}
|
|
11916
12043
|
case 4 /* ClaimOneBtcReward */: {
|
|
11917
|
-
(0,
|
|
12044
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
11918
12045
|
return {
|
|
11919
12046
|
instructionType: 4 /* ClaimOneBtcReward */,
|
|
11920
12047
|
...parseClaimOneBtcRewardInstruction(instruction)
|
|
11921
12048
|
};
|
|
11922
12049
|
}
|
|
11923
12050
|
case 5 /* ClaimSats */: {
|
|
11924
|
-
(0,
|
|
12051
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
11925
12052
|
return {
|
|
11926
12053
|
instructionType: 5 /* ClaimSats */,
|
|
11927
12054
|
...parseClaimSatsInstruction(instruction)
|
|
11928
12055
|
};
|
|
11929
12056
|
}
|
|
11930
12057
|
case 6 /* ClaimUsd */: {
|
|
11931
|
-
(0,
|
|
12058
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
11932
12059
|
return {
|
|
11933
12060
|
instructionType: 6 /* ClaimUsd */,
|
|
11934
12061
|
...parseClaimUsdInstruction(instruction)
|
|
11935
12062
|
};
|
|
11936
12063
|
}
|
|
11937
12064
|
case 7 /* CloseEpochEntry */: {
|
|
11938
|
-
(0,
|
|
12065
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
11939
12066
|
return {
|
|
11940
12067
|
instructionType: 7 /* CloseEpochEntry */,
|
|
11941
12068
|
...parseCloseEpochEntryInstruction(instruction)
|
|
11942
12069
|
};
|
|
11943
12070
|
}
|
|
11944
12071
|
case 8 /* CloseEpochIteration */: {
|
|
11945
|
-
(0,
|
|
12072
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
11946
12073
|
return {
|
|
11947
12074
|
instructionType: 8 /* CloseEpochIteration */,
|
|
11948
12075
|
...parseCloseEpochIterationInstruction(instruction)
|
|
11949
12076
|
};
|
|
11950
12077
|
}
|
|
11951
12078
|
case 9 /* CloseEpochPage */: {
|
|
11952
|
-
(0,
|
|
12079
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
11953
12080
|
return {
|
|
11954
12081
|
instructionType: 9 /* CloseEpochPage */,
|
|
11955
12082
|
...parseCloseEpochPageInstruction(instruction)
|
|
11956
12083
|
};
|
|
11957
12084
|
}
|
|
11958
12085
|
case 10 /* CloseOneBtcIteration */: {
|
|
11959
|
-
(0,
|
|
12086
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
11960
12087
|
return {
|
|
11961
12088
|
instructionType: 10 /* CloseOneBtcIteration */,
|
|
11962
12089
|
...parseCloseOneBtcIterationInstruction(instruction)
|
|
11963
12090
|
};
|
|
11964
12091
|
}
|
|
11965
12092
|
case 11 /* CloseOneBtcTicket */: {
|
|
11966
|
-
(0,
|
|
12093
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
11967
12094
|
return {
|
|
11968
12095
|
instructionType: 11 /* CloseOneBtcTicket */,
|
|
11969
12096
|
...parseCloseOneBtcTicketInstruction(instruction)
|
|
11970
12097
|
};
|
|
11971
12098
|
}
|
|
11972
12099
|
case 12 /* CloseRound */: {
|
|
11973
|
-
(0,
|
|
12100
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
11974
12101
|
return {
|
|
11975
12102
|
instructionType: 12 /* CloseRound */,
|
|
11976
12103
|
...parseCloseRoundInstruction(instruction)
|
|
11977
12104
|
};
|
|
11978
12105
|
}
|
|
11979
12106
|
case 13 /* CreateBoard */: {
|
|
11980
|
-
(0,
|
|
12107
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
11981
12108
|
return {
|
|
11982
12109
|
instructionType: 13 /* CreateBoard */,
|
|
11983
12110
|
...parseCreateBoardInstruction(instruction)
|
|
11984
12111
|
};
|
|
11985
12112
|
}
|
|
11986
12113
|
case 14 /* CreateEpochVault */: {
|
|
11987
|
-
(0,
|
|
12114
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
11988
12115
|
return {
|
|
11989
12116
|
instructionType: 14 /* CreateEpochVault */,
|
|
11990
12117
|
...parseCreateEpochVaultInstruction(instruction)
|
|
11991
12118
|
};
|
|
11992
12119
|
}
|
|
11993
12120
|
case 15 /* CreateOneBtcVault */: {
|
|
11994
|
-
(0,
|
|
12121
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
11995
12122
|
return {
|
|
11996
12123
|
instructionType: 15 /* CreateOneBtcVault */,
|
|
11997
12124
|
...parseCreateOneBtcVaultInstruction(instruction)
|
|
11998
12125
|
};
|
|
11999
12126
|
}
|
|
12000
12127
|
case 16 /* CreatePublicAutomation */: {
|
|
12001
|
-
(0,
|
|
12128
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12002
12129
|
return {
|
|
12003
12130
|
instructionType: 16 /* CreatePublicAutomation */,
|
|
12004
12131
|
...parseCreatePublicAutomationInstruction(instruction)
|
|
12005
12132
|
};
|
|
12006
12133
|
}
|
|
12007
12134
|
case 17 /* CreateSatrushConfig */: {
|
|
12008
|
-
(0,
|
|
12135
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12009
12136
|
return {
|
|
12010
12137
|
instructionType: 17 /* CreateSatrushConfig */,
|
|
12011
12138
|
...parseCreateSatrushConfigInstruction(instruction)
|
|
12012
12139
|
};
|
|
12013
12140
|
}
|
|
12014
12141
|
case 18 /* CreateSatsVault */: {
|
|
12015
|
-
(0,
|
|
12142
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12016
12143
|
return {
|
|
12017
12144
|
instructionType: 18 /* CreateSatsVault */,
|
|
12018
12145
|
...parseCreateSatsVaultInstruction(instruction)
|
|
12019
12146
|
};
|
|
12020
12147
|
}
|
|
12021
12148
|
case 19 /* CreateTreasury */: {
|
|
12022
|
-
(0,
|
|
12149
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12023
12150
|
return {
|
|
12024
12151
|
instructionType: 19 /* CreateTreasury */,
|
|
12025
12152
|
...parseCreateTreasuryInstruction(instruction)
|
|
12026
12153
|
};
|
|
12027
12154
|
}
|
|
12028
12155
|
case 20 /* DeployPublic */: {
|
|
12029
|
-
(0,
|
|
12156
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12030
12157
|
return {
|
|
12031
12158
|
instructionType: 20 /* DeployPublic */,
|
|
12032
12159
|
...parseDeployPublicInstruction(instruction)
|
|
12033
12160
|
};
|
|
12034
12161
|
}
|
|
12035
12162
|
case 21 /* ExecutePublicAutomation */: {
|
|
12036
|
-
(0,
|
|
12163
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12037
12164
|
return {
|
|
12038
12165
|
instructionType: 21 /* ExecutePublicAutomation */,
|
|
12039
12166
|
...parseExecutePublicAutomationInstruction(instruction)
|
|
12040
12167
|
};
|
|
12041
12168
|
}
|
|
12042
12169
|
case 22 /* RotateRound */: {
|
|
12043
|
-
(0,
|
|
12170
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12044
12171
|
return {
|
|
12045
12172
|
instructionType: 22 /* RotateRound */,
|
|
12046
12173
|
...parseRotateRoundInstruction(instruction)
|
|
12047
12174
|
};
|
|
12048
12175
|
}
|
|
12049
12176
|
case 23 /* SealEpochPage */: {
|
|
12050
|
-
(0,
|
|
12177
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12051
12178
|
return {
|
|
12052
12179
|
instructionType: 23 /* SealEpochPage */,
|
|
12053
12180
|
...parseSealEpochPageInstruction(instruction)
|
|
12054
12181
|
};
|
|
12055
12182
|
}
|
|
12056
12183
|
case 24 /* SelectEpochWinner */: {
|
|
12057
|
-
(0,
|
|
12184
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12058
12185
|
return {
|
|
12059
12186
|
instructionType: 24 /* SelectEpochWinner */,
|
|
12060
12187
|
...parseSelectEpochWinnerInstruction(instruction)
|
|
12061
12188
|
};
|
|
12062
12189
|
}
|
|
12063
12190
|
case 25 /* SettleDeployPublic */: {
|
|
12064
|
-
(0,
|
|
12191
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12065
12192
|
return {
|
|
12066
12193
|
instructionType: 25 /* SettleDeployPublic */,
|
|
12067
12194
|
...parseSettleDeployPublicInstruction(instruction)
|
|
12068
12195
|
};
|
|
12069
12196
|
}
|
|
12070
12197
|
case 26 /* SwapEpochStake */: {
|
|
12071
|
-
(0,
|
|
12198
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12072
12199
|
return {
|
|
12073
12200
|
instructionType: 26 /* SwapEpochStake */,
|
|
12074
12201
|
...parseSwapEpochStakeInstruction(instruction)
|
|
12075
12202
|
};
|
|
12076
12203
|
}
|
|
12077
12204
|
case 27 /* SwapOneBtcStake */: {
|
|
12078
|
-
(0,
|
|
12205
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12079
12206
|
return {
|
|
12080
12207
|
instructionType: 27 /* SwapOneBtcStake */,
|
|
12081
12208
|
...parseSwapOneBtcStakeInstruction(instruction)
|
|
12082
12209
|
};
|
|
12083
12210
|
}
|
|
12084
12211
|
case 28 /* SwapRoundStake */: {
|
|
12085
|
-
(0,
|
|
12212
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12086
12213
|
return {
|
|
12087
12214
|
instructionType: 28 /* SwapRoundStake */,
|
|
12088
12215
|
...parseSwapRoundStakeInstruction(instruction)
|
|
12089
12216
|
};
|
|
12090
12217
|
}
|
|
12091
12218
|
case 29 /* SwapStrikeStake */: {
|
|
12092
|
-
(0,
|
|
12219
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12093
12220
|
return {
|
|
12094
12221
|
instructionType: 29 /* SwapStrikeStake */,
|
|
12095
12222
|
...parseSwapStrikeStakeInstruction(instruction)
|
|
12096
12223
|
};
|
|
12097
12224
|
}
|
|
12098
12225
|
case 30 /* TopUpPublicAutomation */: {
|
|
12099
|
-
(0,
|
|
12226
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12100
12227
|
return {
|
|
12101
12228
|
instructionType: 30 /* TopUpPublicAutomation */,
|
|
12102
12229
|
...parseTopUpPublicAutomationInstruction(instruction)
|
|
12103
12230
|
};
|
|
12104
12231
|
}
|
|
12105
12232
|
case 31 /* TriggerEpochDraw */: {
|
|
12106
|
-
(0,
|
|
12233
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12107
12234
|
return {
|
|
12108
12235
|
instructionType: 31 /* TriggerEpochDraw */,
|
|
12109
12236
|
...parseTriggerEpochDrawInstruction(instruction)
|
|
12110
12237
|
};
|
|
12111
12238
|
}
|
|
12112
12239
|
case 32 /* TriggerOneBtcDraw */: {
|
|
12113
|
-
(0,
|
|
12240
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12114
12241
|
return {
|
|
12115
12242
|
instructionType: 32 /* TriggerOneBtcDraw */,
|
|
12116
12243
|
...parseTriggerOneBtcDrawInstruction(instruction)
|
|
12117
12244
|
};
|
|
12118
12245
|
}
|
|
12119
12246
|
case 33 /* UpdateBoardRoundDuration */: {
|
|
12120
|
-
(0,
|
|
12247
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12121
12248
|
return {
|
|
12122
12249
|
instructionType: 33 /* UpdateBoardRoundDuration */,
|
|
12123
12250
|
...parseUpdateBoardRoundDurationInstruction(instruction)
|
|
12124
12251
|
};
|
|
12125
12252
|
}
|
|
12126
12253
|
case 34 /* UpdateDeploymentSettleGraceDuration */: {
|
|
12127
|
-
(0,
|
|
12254
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12128
12255
|
return {
|
|
12129
12256
|
instructionType: 34 /* UpdateDeploymentSettleGraceDuration */,
|
|
12130
12257
|
...parseUpdateDeploymentSettleGraceDurationInstruction(instruction)
|
|
12131
12258
|
};
|
|
12132
12259
|
}
|
|
12133
12260
|
case 35 /* UpdateEpochVaultIterationDuration */: {
|
|
12134
|
-
(0,
|
|
12261
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12135
12262
|
return {
|
|
12136
12263
|
instructionType: 35 /* UpdateEpochVaultIterationDuration */,
|
|
12137
12264
|
...parseUpdateEpochVaultIterationDurationInstruction(instruction)
|
|
12138
12265
|
};
|
|
12139
12266
|
}
|
|
12140
12267
|
case 36 /* UpdateMinDeployUsdAmount */: {
|
|
12141
|
-
(0,
|
|
12268
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12142
12269
|
return {
|
|
12143
12270
|
instructionType: 36 /* UpdateMinDeployUsdAmount */,
|
|
12144
12271
|
...parseUpdateMinDeployUsdAmountInstruction(instruction)
|
|
12145
12272
|
};
|
|
12146
12273
|
}
|
|
12147
|
-
case 37 /*
|
|
12148
|
-
(0,
|
|
12274
|
+
case 37 /* UpdateStrikeTriggerModulus */: {
|
|
12275
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12149
12276
|
return {
|
|
12150
|
-
instructionType: 37 /*
|
|
12277
|
+
instructionType: 37 /* UpdateStrikeTriggerModulus */,
|
|
12278
|
+
...parseUpdateStrikeTriggerModulusInstruction(instruction)
|
|
12279
|
+
};
|
|
12280
|
+
}
|
|
12281
|
+
case 38 /* UpdateUnclaimedHashrateBps */: {
|
|
12282
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12283
|
+
return {
|
|
12284
|
+
instructionType: 38 /* UpdateUnclaimedHashrateBps */,
|
|
12151
12285
|
...parseUpdateUnclaimedHashrateBpsInstruction(instruction)
|
|
12152
12286
|
};
|
|
12153
12287
|
}
|
|
12154
|
-
case
|
|
12155
|
-
(0,
|
|
12288
|
+
case 39 /* WithdrawProtocolFees */: {
|
|
12289
|
+
(0, import_kit85.assertIsInstructionWithAccounts)(instruction);
|
|
12156
12290
|
return {
|
|
12157
|
-
instructionType:
|
|
12291
|
+
instructionType: 39 /* WithdrawProtocolFees */,
|
|
12158
12292
|
...parseWithdrawProtocolFeesInstruction(instruction)
|
|
12159
12293
|
};
|
|
12160
12294
|
}
|
|
12161
12295
|
default:
|
|
12162
|
-
throw new
|
|
12163
|
-
|
|
12296
|
+
throw new import_kit85.SolanaError(
|
|
12297
|
+
import_kit85.SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
|
|
12164
12298
|
{ instructionType, programName: "satrush" }
|
|
12165
12299
|
);
|
|
12166
12300
|
}
|
|
12167
12301
|
}
|
|
12168
12302
|
function satrushProgram() {
|
|
12169
12303
|
return (client) => {
|
|
12170
|
-
return (0,
|
|
12304
|
+
return (0, import_kit85.extendClient)(client, {
|
|
12171
12305
|
satrush: {
|
|
12172
12306
|
accounts: {
|
|
12173
|
-
board: (0,
|
|
12174
|
-
epochVault: (0,
|
|
12175
|
-
epochVaultEntry: (0,
|
|
12307
|
+
board: (0, import_program_client_core41.addSelfFetchFunctions)(client, getBoardCodec()),
|
|
12308
|
+
epochVault: (0, import_program_client_core41.addSelfFetchFunctions)(client, getEpochVaultCodec()),
|
|
12309
|
+
epochVaultEntry: (0, import_program_client_core41.addSelfFetchFunctions)(
|
|
12176
12310
|
client,
|
|
12177
12311
|
getEpochVaultEntryCodec()
|
|
12178
12312
|
),
|
|
12179
|
-
epochVaultIteration: (0,
|
|
12313
|
+
epochVaultIteration: (0, import_program_client_core41.addSelfFetchFunctions)(
|
|
12180
12314
|
client,
|
|
12181
12315
|
getEpochVaultIterationCodec()
|
|
12182
12316
|
),
|
|
12183
|
-
epochVaultPage: (0,
|
|
12317
|
+
epochVaultPage: (0, import_program_client_core41.addSelfFetchFunctions)(
|
|
12184
12318
|
client,
|
|
12185
12319
|
getEpochVaultPageCodec()
|
|
12186
12320
|
),
|
|
12187
|
-
miner: (0,
|
|
12188
|
-
oneBtcVault: (0,
|
|
12189
|
-
oneBtcVaultEntry: (0,
|
|
12321
|
+
miner: (0, import_program_client_core41.addSelfFetchFunctions)(client, getMinerCodec()),
|
|
12322
|
+
oneBtcVault: (0, import_program_client_core41.addSelfFetchFunctions)(client, getOneBtcVaultCodec()),
|
|
12323
|
+
oneBtcVaultEntry: (0, import_program_client_core41.addSelfFetchFunctions)(
|
|
12190
12324
|
client,
|
|
12191
12325
|
getOneBtcVaultEntryCodec()
|
|
12192
12326
|
),
|
|
12193
|
-
oneBtcVaultIteration: (0,
|
|
12327
|
+
oneBtcVaultIteration: (0, import_program_client_core41.addSelfFetchFunctions)(
|
|
12194
12328
|
client,
|
|
12195
12329
|
getOneBtcVaultIterationCodec()
|
|
12196
12330
|
),
|
|
12197
|
-
publicAutomation: (0,
|
|
12331
|
+
publicAutomation: (0, import_program_client_core41.addSelfFetchFunctions)(
|
|
12198
12332
|
client,
|
|
12199
12333
|
getPublicAutomationCodec()
|
|
12200
12334
|
),
|
|
12201
|
-
publicDeployment: (0,
|
|
12335
|
+
publicDeployment: (0, import_program_client_core41.addSelfFetchFunctions)(
|
|
12202
12336
|
client,
|
|
12203
12337
|
getPublicDeploymentCodec()
|
|
12204
12338
|
),
|
|
12205
|
-
round: (0,
|
|
12206
|
-
satrushConfig: (0,
|
|
12207
|
-
satsVault: (0,
|
|
12208
|
-
treasury: (0,
|
|
12339
|
+
round: (0, import_program_client_core41.addSelfFetchFunctions)(client, getRoundCodec()),
|
|
12340
|
+
satrushConfig: (0, import_program_client_core41.addSelfFetchFunctions)(client, getSatrushConfigCodec()),
|
|
12341
|
+
satsVault: (0, import_program_client_core41.addSelfFetchFunctions)(client, getSatsVaultCodec()),
|
|
12342
|
+
treasury: (0, import_program_client_core41.addSelfFetchFunctions)(client, getTreasuryCodec())
|
|
12209
12343
|
},
|
|
12210
12344
|
instructions: {
|
|
12211
|
-
buyEpochTickets: (input) => (0,
|
|
12345
|
+
buyEpochTickets: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12212
12346
|
client,
|
|
12213
12347
|
getBuyEpochTicketsInstructionAsync(input)
|
|
12214
12348
|
),
|
|
12215
|
-
buyOneBtcTickets: (input) => (0,
|
|
12349
|
+
buyOneBtcTickets: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12216
12350
|
client,
|
|
12217
12351
|
getBuyOneBtcTicketsInstructionAsync(input)
|
|
12218
12352
|
),
|
|
12219
|
-
cancelPublicAutomation: (input) => (0,
|
|
12353
|
+
cancelPublicAutomation: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12220
12354
|
client,
|
|
12221
12355
|
getCancelPublicAutomationInstructionAsync(input)
|
|
12222
12356
|
),
|
|
12223
|
-
claimEpochReward: (input) => (0,
|
|
12357
|
+
claimEpochReward: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12224
12358
|
client,
|
|
12225
12359
|
getClaimEpochRewardInstructionAsync(input)
|
|
12226
12360
|
),
|
|
12227
|
-
claimOneBtcReward: (input) => (0,
|
|
12361
|
+
claimOneBtcReward: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12228
12362
|
client,
|
|
12229
12363
|
getClaimOneBtcRewardInstructionAsync(input)
|
|
12230
12364
|
),
|
|
12231
|
-
claimSats: (input) => (0,
|
|
12365
|
+
claimSats: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12232
12366
|
client,
|
|
12233
12367
|
getClaimSatsInstructionAsync(input)
|
|
12234
12368
|
),
|
|
12235
|
-
claimUsd: (input) => (0,
|
|
12369
|
+
claimUsd: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12236
12370
|
client,
|
|
12237
12371
|
getClaimUsdInstructionAsync(input)
|
|
12238
12372
|
),
|
|
12239
|
-
closeEpochEntry: (input) => (0,
|
|
12373
|
+
closeEpochEntry: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12240
12374
|
client,
|
|
12241
12375
|
getCloseEpochEntryInstructionAsync(input)
|
|
12242
12376
|
),
|
|
12243
|
-
closeEpochIteration: (input) => (0,
|
|
12377
|
+
closeEpochIteration: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12244
12378
|
client,
|
|
12245
12379
|
getCloseEpochIterationInstructionAsync(input)
|
|
12246
12380
|
),
|
|
12247
|
-
closeEpochPage: (input) => (0,
|
|
12381
|
+
closeEpochPage: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12248
12382
|
client,
|
|
12249
12383
|
getCloseEpochPageInstructionAsync(input)
|
|
12250
12384
|
),
|
|
12251
|
-
closeOneBtcIteration: (input) => (0,
|
|
12385
|
+
closeOneBtcIteration: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12252
12386
|
client,
|
|
12253
12387
|
getCloseOneBtcIterationInstructionAsync(input)
|
|
12254
12388
|
),
|
|
12255
|
-
closeOneBtcTicket: (input) => (0,
|
|
12389
|
+
closeOneBtcTicket: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12256
12390
|
client,
|
|
12257
12391
|
getCloseOneBtcTicketInstruction(input)
|
|
12258
12392
|
),
|
|
12259
|
-
closeRound: (input) => (0,
|
|
12393
|
+
closeRound: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12260
12394
|
client,
|
|
12261
12395
|
getCloseRoundInstructionAsync(input)
|
|
12262
12396
|
),
|
|
12263
|
-
createBoard: (input) => (0,
|
|
12397
|
+
createBoard: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12264
12398
|
client,
|
|
12265
12399
|
getCreateBoardInstructionAsync(input)
|
|
12266
12400
|
),
|
|
12267
|
-
createEpochVault: (input) => (0,
|
|
12401
|
+
createEpochVault: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12268
12402
|
client,
|
|
12269
12403
|
getCreateEpochVaultInstructionAsync(input)
|
|
12270
12404
|
),
|
|
12271
|
-
createOneBtcVault: (input) => (0,
|
|
12405
|
+
createOneBtcVault: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12272
12406
|
client,
|
|
12273
12407
|
getCreateOneBtcVaultInstructionAsync(input)
|
|
12274
12408
|
),
|
|
12275
|
-
createPublicAutomation: (input) => (0,
|
|
12409
|
+
createPublicAutomation: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12276
12410
|
client,
|
|
12277
12411
|
getCreatePublicAutomationInstructionAsync(input)
|
|
12278
12412
|
),
|
|
12279
|
-
createSatrushConfig: (input) => (0,
|
|
12413
|
+
createSatrushConfig: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12280
12414
|
client,
|
|
12281
12415
|
getCreateSatrushConfigInstructionAsync(input)
|
|
12282
12416
|
),
|
|
12283
|
-
createSatsVault: (input) => (0,
|
|
12417
|
+
createSatsVault: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12284
12418
|
client,
|
|
12285
12419
|
getCreateSatsVaultInstructionAsync(input)
|
|
12286
12420
|
),
|
|
12287
|
-
createTreasury: (input) => (0,
|
|
12421
|
+
createTreasury: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12288
12422
|
client,
|
|
12289
12423
|
getCreateTreasuryInstructionAsync(input)
|
|
12290
12424
|
),
|
|
12291
|
-
deployPublic: (input) => (0,
|
|
12425
|
+
deployPublic: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12292
12426
|
client,
|
|
12293
12427
|
getDeployPublicInstructionAsync(input)
|
|
12294
12428
|
),
|
|
12295
|
-
executePublicAutomation: (input) => (0,
|
|
12429
|
+
executePublicAutomation: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12296
12430
|
client,
|
|
12297
12431
|
getExecutePublicAutomationInstructionAsync(input)
|
|
12298
12432
|
),
|
|
12299
|
-
rotateRound: (input) => (0,
|
|
12433
|
+
rotateRound: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12300
12434
|
client,
|
|
12301
12435
|
getRotateRoundInstructionAsync(input)
|
|
12302
12436
|
),
|
|
12303
|
-
sealEpochPage: (input) => (0,
|
|
12437
|
+
sealEpochPage: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12304
12438
|
client,
|
|
12305
12439
|
getSealEpochPageInstructionAsync(input)
|
|
12306
12440
|
),
|
|
12307
|
-
selectEpochWinner: (input) => (0,
|
|
12441
|
+
selectEpochWinner: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12308
12442
|
client,
|
|
12309
12443
|
getSelectEpochWinnerInstructionAsync(input)
|
|
12310
12444
|
),
|
|
12311
|
-
settleDeployPublic: (input) => (0,
|
|
12445
|
+
settleDeployPublic: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12312
12446
|
client,
|
|
12313
12447
|
getSettleDeployPublicInstructionAsync(input)
|
|
12314
12448
|
),
|
|
12315
|
-
swapEpochStake: (input) => (0,
|
|
12449
|
+
swapEpochStake: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12316
12450
|
client,
|
|
12317
12451
|
getSwapEpochStakeInstructionAsync(input)
|
|
12318
12452
|
),
|
|
12319
|
-
swapOneBtcStake: (input) => (0,
|
|
12453
|
+
swapOneBtcStake: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12320
12454
|
client,
|
|
12321
12455
|
getSwapOneBtcStakeInstructionAsync(input)
|
|
12322
12456
|
),
|
|
12323
|
-
swapRoundStake: (input) => (0,
|
|
12457
|
+
swapRoundStake: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12324
12458
|
client,
|
|
12325
12459
|
getSwapRoundStakeInstructionAsync(input)
|
|
12326
12460
|
),
|
|
12327
|
-
swapStrikeStake: (input) => (0,
|
|
12461
|
+
swapStrikeStake: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12328
12462
|
client,
|
|
12329
12463
|
getSwapStrikeStakeInstructionAsync(input)
|
|
12330
12464
|
),
|
|
12331
|
-
topUpPublicAutomation: (input) => (0,
|
|
12465
|
+
topUpPublicAutomation: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12332
12466
|
client,
|
|
12333
12467
|
getTopUpPublicAutomationInstructionAsync(input)
|
|
12334
12468
|
),
|
|
12335
|
-
triggerEpochDraw: (input) => (0,
|
|
12469
|
+
triggerEpochDraw: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12336
12470
|
client,
|
|
12337
12471
|
getTriggerEpochDrawInstructionAsync(input)
|
|
12338
12472
|
),
|
|
12339
|
-
triggerOneBtcDraw: (input) => (0,
|
|
12473
|
+
triggerOneBtcDraw: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12340
12474
|
client,
|
|
12341
12475
|
getTriggerOneBtcDrawInstructionAsync(input)
|
|
12342
12476
|
),
|
|
12343
|
-
updateBoardRoundDuration: (input) => (0,
|
|
12477
|
+
updateBoardRoundDuration: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12344
12478
|
client,
|
|
12345
12479
|
getUpdateBoardRoundDurationInstructionAsync(input)
|
|
12346
12480
|
),
|
|
12347
|
-
updateDeploymentSettleGraceDuration: (input) => (0,
|
|
12481
|
+
updateDeploymentSettleGraceDuration: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12348
12482
|
client,
|
|
12349
12483
|
getUpdateDeploymentSettleGraceDurationInstructionAsync(input)
|
|
12350
12484
|
),
|
|
12351
|
-
updateEpochVaultIterationDuration: (input) => (0,
|
|
12485
|
+
updateEpochVaultIterationDuration: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12352
12486
|
client,
|
|
12353
12487
|
getUpdateEpochVaultIterationDurationInstructionAsync(input)
|
|
12354
12488
|
),
|
|
12355
|
-
updateMinDeployUsdAmount: (input) => (0,
|
|
12489
|
+
updateMinDeployUsdAmount: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12356
12490
|
client,
|
|
12357
12491
|
getUpdateMinDeployUsdAmountInstructionAsync(input)
|
|
12358
12492
|
),
|
|
12359
|
-
|
|
12493
|
+
updateStrikeTriggerModulus: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12494
|
+
client,
|
|
12495
|
+
getUpdateStrikeTriggerModulusInstructionAsync(input)
|
|
12496
|
+
),
|
|
12497
|
+
updateUnclaimedHashrateBps: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12360
12498
|
client,
|
|
12361
12499
|
getUpdateUnclaimedHashrateBpsInstructionAsync(input)
|
|
12362
12500
|
),
|
|
12363
|
-
withdrawProtocolFees: (input) => (0,
|
|
12501
|
+
withdrawProtocolFees: (input) => (0, import_program_client_core41.addSelfPlanAndSendFunctions)(
|
|
12364
12502
|
client,
|
|
12365
12503
|
getWithdrawProtocolFeesInstructionAsync(input)
|
|
12366
12504
|
)
|
|
@@ -12438,6 +12576,8 @@ var SATRUSH_ERROR__INVALID_AUTOMATION_STRATEGY_MASK = 6046;
|
|
|
12438
12576
|
var SATRUSH_ERROR__DEPLOY_AMOUNT_BELOW_MINIMUM = 6047;
|
|
12439
12577
|
var SATRUSH_ERROR__INVALID_EPOCH_ITERATION_DURATION = 6048;
|
|
12440
12578
|
var SATRUSH_ERROR__INVALID_UNCLAIMED_HASHRATE_BPS = 6049;
|
|
12579
|
+
var SATRUSH_ERROR__INVALID_STRIKE_TRIGGER_MODULUS = 6050;
|
|
12580
|
+
var SATRUSH_ERROR__INVALID_SWAP_BPS = 6051;
|
|
12441
12581
|
var satrushErrorMessages;
|
|
12442
12582
|
if (process.env["NODE_ENV"] !== "production") {
|
|
12443
12583
|
satrushErrorMessages = {
|
|
@@ -12470,6 +12610,8 @@ if (process.env["NODE_ENV"] !== "production") {
|
|
|
12470
12610
|
[SATRUSH_ERROR__INVALID_SELECTION_MASK]: `Selection mask must pick between 1 and 21 tiles within the 21-bit range`,
|
|
12471
12611
|
[SATRUSH_ERROR__INVALID_SHARE_AMOUNT]: `Share amount must be greater than zero`,
|
|
12472
12612
|
[SATRUSH_ERROR__INVALID_SLOT_HASH]: `Slot hash entropy is unavailable or invalid`,
|
|
12613
|
+
[SATRUSH_ERROR__INVALID_STRIKE_TRIGGER_MODULUS]: `Strike trigger modulus must be greater than zero`,
|
|
12614
|
+
[SATRUSH_ERROR__INVALID_SWAP_BPS]: `Sats Vault round fee bps plus deploy fee bps must stay below 10_000`,
|
|
12473
12615
|
[SATRUSH_ERROR__INVALID_SWAP_PROGRAM]: `Swap program account does not match the configured swap program`,
|
|
12474
12616
|
[SATRUSH_ERROR__INVALID_TICKETS_COUNT]: `Tickets count must be greater than zero`,
|
|
12475
12617
|
[SATRUSH_ERROR__INVALID_UNCLAIMED_HASHRATE_BPS]: `Unclaimed hashrate bps must not exceed 10_000`,
|
|
@@ -12500,7 +12642,7 @@ function getSatrushErrorMessage(code) {
|
|
|
12500
12642
|
return "Error message not available in production bundles.";
|
|
12501
12643
|
}
|
|
12502
12644
|
function isSatrushError(error, transactionMessage, code) {
|
|
12503
|
-
return (0,
|
|
12645
|
+
return (0, import_kit86.isProgramError)(
|
|
12504
12646
|
error,
|
|
12505
12647
|
transactionMessage,
|
|
12506
12648
|
SATRUSH_PROGRAM_ADDRESS,
|
|
@@ -12509,111 +12651,111 @@ function isSatrushError(error, transactionMessage, code) {
|
|
|
12509
12651
|
}
|
|
12510
12652
|
|
|
12511
12653
|
// src/builders.ts
|
|
12512
|
-
var
|
|
12654
|
+
var import_kit88 = require("@solana/kit");
|
|
12513
12655
|
var import_token = require("@solana-program/token");
|
|
12514
12656
|
|
|
12515
12657
|
// src/pda.ts
|
|
12516
|
-
var
|
|
12658
|
+
var import_kit87 = require("@solana/kit");
|
|
12517
12659
|
async function getSatrushConfigAddress() {
|
|
12518
|
-
return await (0,
|
|
12660
|
+
return await (0, import_kit87.getProgramDerivedAddress)({
|
|
12519
12661
|
programAddress: SATRUSH_PROGRAM_ADDRESS,
|
|
12520
12662
|
seeds: ["satrush_config"]
|
|
12521
12663
|
});
|
|
12522
12664
|
}
|
|
12523
12665
|
async function getEventAuthorityAddress() {
|
|
12524
|
-
return await (0,
|
|
12666
|
+
return await (0, import_kit87.getProgramDerivedAddress)({
|
|
12525
12667
|
programAddress: SATRUSH_PROGRAM_ADDRESS,
|
|
12526
12668
|
seeds: ["__event_authority"]
|
|
12527
12669
|
});
|
|
12528
12670
|
}
|
|
12529
12671
|
async function getBoardAddress() {
|
|
12530
|
-
return await (0,
|
|
12672
|
+
return await (0, import_kit87.getProgramDerivedAddress)({
|
|
12531
12673
|
programAddress: SATRUSH_PROGRAM_ADDRESS,
|
|
12532
12674
|
seeds: ["board"]
|
|
12533
12675
|
});
|
|
12534
12676
|
}
|
|
12535
12677
|
async function getRoundAddress(roundId) {
|
|
12536
|
-
return await (0,
|
|
12678
|
+
return await (0, import_kit87.getProgramDerivedAddress)({
|
|
12537
12679
|
programAddress: SATRUSH_PROGRAM_ADDRESS,
|
|
12538
|
-
seeds: ["round", (0,
|
|
12680
|
+
seeds: ["round", (0, import_kit87.getU32Encoder)().encode(roundId)]
|
|
12539
12681
|
});
|
|
12540
12682
|
}
|
|
12541
12683
|
async function getPublicDeploymentAddress(authority, roundId) {
|
|
12542
|
-
return await (0,
|
|
12684
|
+
return await (0, import_kit87.getProgramDerivedAddress)({
|
|
12543
12685
|
programAddress: SATRUSH_PROGRAM_ADDRESS,
|
|
12544
12686
|
seeds: [
|
|
12545
12687
|
"public_deployment",
|
|
12546
|
-
(0,
|
|
12547
|
-
(0,
|
|
12688
|
+
(0, import_kit87.getAddressEncoder)().encode(authority),
|
|
12689
|
+
(0, import_kit87.getU32Encoder)().encode(roundId)
|
|
12548
12690
|
]
|
|
12549
12691
|
});
|
|
12550
12692
|
}
|
|
12551
12693
|
async function getMinerAddress(authority) {
|
|
12552
|
-
return await (0,
|
|
12694
|
+
return await (0, import_kit87.getProgramDerivedAddress)({
|
|
12553
12695
|
programAddress: SATRUSH_PROGRAM_ADDRESS,
|
|
12554
|
-
seeds: ["miner", (0,
|
|
12696
|
+
seeds: ["miner", (0, import_kit87.getAddressEncoder)().encode(authority)]
|
|
12555
12697
|
});
|
|
12556
12698
|
}
|
|
12557
12699
|
async function getSatsVaultAddress() {
|
|
12558
|
-
return await (0,
|
|
12700
|
+
return await (0, import_kit87.getProgramDerivedAddress)({
|
|
12559
12701
|
programAddress: SATRUSH_PROGRAM_ADDRESS,
|
|
12560
12702
|
seeds: ["sats_vault"]
|
|
12561
12703
|
});
|
|
12562
12704
|
}
|
|
12563
12705
|
async function getEpochVaultAddress() {
|
|
12564
|
-
return await (0,
|
|
12706
|
+
return await (0, import_kit87.getProgramDerivedAddress)({
|
|
12565
12707
|
programAddress: SATRUSH_PROGRAM_ADDRESS,
|
|
12566
12708
|
seeds: ["epoch_vault"]
|
|
12567
12709
|
});
|
|
12568
12710
|
}
|
|
12569
12711
|
async function getEpochVaultIterationAddress(iterationId) {
|
|
12570
|
-
return await (0,
|
|
12712
|
+
return await (0, import_kit87.getProgramDerivedAddress)({
|
|
12571
12713
|
programAddress: SATRUSH_PROGRAM_ADDRESS,
|
|
12572
|
-
seeds: ["epoch_vault_iteration", (0,
|
|
12714
|
+
seeds: ["epoch_vault_iteration", (0, import_kit87.getU32Encoder)().encode(iterationId)]
|
|
12573
12715
|
});
|
|
12574
12716
|
}
|
|
12575
12717
|
async function getEpochVaultEntryAddress(iterationId, authority) {
|
|
12576
|
-
return await (0,
|
|
12718
|
+
return await (0, import_kit87.getProgramDerivedAddress)({
|
|
12577
12719
|
programAddress: SATRUSH_PROGRAM_ADDRESS,
|
|
12578
12720
|
seeds: [
|
|
12579
12721
|
"epoch_vault_entry",
|
|
12580
|
-
(0,
|
|
12581
|
-
(0,
|
|
12722
|
+
(0, import_kit87.getU32Encoder)().encode(iterationId),
|
|
12723
|
+
(0, import_kit87.getAddressEncoder)().encode(authority)
|
|
12582
12724
|
]
|
|
12583
12725
|
});
|
|
12584
12726
|
}
|
|
12585
12727
|
async function getEpochVaultPageAddress(iterationId, pageIndex) {
|
|
12586
|
-
return await (0,
|
|
12728
|
+
return await (0, import_kit87.getProgramDerivedAddress)({
|
|
12587
12729
|
programAddress: SATRUSH_PROGRAM_ADDRESS,
|
|
12588
12730
|
seeds: [
|
|
12589
12731
|
"epoch_vault_page",
|
|
12590
|
-
(0,
|
|
12591
|
-
(0,
|
|
12732
|
+
(0, import_kit87.getU32Encoder)().encode(iterationId),
|
|
12733
|
+
(0, import_kit87.getU16Encoder)().encode(pageIndex)
|
|
12592
12734
|
]
|
|
12593
12735
|
});
|
|
12594
12736
|
}
|
|
12595
12737
|
async function getOneBtcVaultAddress() {
|
|
12596
|
-
return await (0,
|
|
12738
|
+
return await (0, import_kit87.getProgramDerivedAddress)({
|
|
12597
12739
|
programAddress: SATRUSH_PROGRAM_ADDRESS,
|
|
12598
12740
|
seeds: ["one_btc_vault"]
|
|
12599
12741
|
});
|
|
12600
12742
|
}
|
|
12601
12743
|
async function getOneBtcVaultIterationAddress(iterationId) {
|
|
12602
|
-
return await (0,
|
|
12744
|
+
return await (0, import_kit87.getProgramDerivedAddress)({
|
|
12603
12745
|
programAddress: SATRUSH_PROGRAM_ADDRESS,
|
|
12604
|
-
seeds: ["one_btc_vault_iteration", (0,
|
|
12746
|
+
seeds: ["one_btc_vault_iteration", (0, import_kit87.getU32Encoder)().encode(iterationId)]
|
|
12605
12747
|
});
|
|
12606
12748
|
}
|
|
12607
12749
|
async function getTreasuryAddress() {
|
|
12608
|
-
return await (0,
|
|
12750
|
+
return await (0, import_kit87.getProgramDerivedAddress)({
|
|
12609
12751
|
programAddress: SATRUSH_PROGRAM_ADDRESS,
|
|
12610
12752
|
seeds: ["treasury"]
|
|
12611
12753
|
});
|
|
12612
12754
|
}
|
|
12613
12755
|
async function getPublicAutomationAddress(authority) {
|
|
12614
|
-
return await (0,
|
|
12756
|
+
return await (0, import_kit87.getProgramDerivedAddress)({
|
|
12615
12757
|
programAddress: SATRUSH_PROGRAM_ADDRESS,
|
|
12616
|
-
seeds: ["public_automation", (0,
|
|
12758
|
+
seeds: ["public_automation", (0, import_kit87.getAddressEncoder)().encode(authority)]
|
|
12617
12759
|
});
|
|
12618
12760
|
}
|
|
12619
12761
|
|
|
@@ -12631,7 +12773,7 @@ async function buildDeployPublicInstruction(authority, usdMint, roundId, selecti
|
|
|
12631
12773
|
});
|
|
12632
12774
|
const [eventAuthority] = await getEventAuthorityAddress();
|
|
12633
12775
|
return await getDeployPublicInstructionAsync({
|
|
12634
|
-
authority: (0,
|
|
12776
|
+
authority: (0, import_kit88.createNoopSigner)(authority),
|
|
12635
12777
|
usdMint,
|
|
12636
12778
|
round,
|
|
12637
12779
|
authorityUsdAta,
|
|
@@ -12657,7 +12799,7 @@ async function buildSettleDeployPublicInstruction(authority, deploymentAuthority
|
|
|
12657
12799
|
mint: usdMint
|
|
12658
12800
|
});
|
|
12659
12801
|
return await getSettleDeployPublicInstructionAsync({
|
|
12660
|
-
authority: (0,
|
|
12802
|
+
authority: (0, import_kit88.createNoopSigner)(authority),
|
|
12661
12803
|
rentRecipient,
|
|
12662
12804
|
round,
|
|
12663
12805
|
publicDeployment,
|
|
@@ -12673,7 +12815,7 @@ async function buildSettleDeployPublicInstruction(authority, deploymentAuthority
|
|
|
12673
12815
|
async function buildClaimSatsInstruction(authority, btcMint, shares) {
|
|
12674
12816
|
const [eventAuthority] = await getEventAuthorityAddress();
|
|
12675
12817
|
return await getClaimSatsInstructionAsync({
|
|
12676
|
-
authority: (0,
|
|
12818
|
+
authority: (0, import_kit88.createNoopSigner)(authority),
|
|
12677
12819
|
btcMint,
|
|
12678
12820
|
shares,
|
|
12679
12821
|
eventAuthority,
|
|
@@ -12682,7 +12824,7 @@ async function buildClaimSatsInstruction(authority, btcMint, shares) {
|
|
|
12682
12824
|
}
|
|
12683
12825
|
async function buildClaimUsdInstruction(authority, usdMint, amount) {
|
|
12684
12826
|
return await getClaimUsdInstructionAsync({
|
|
12685
|
-
authority: (0,
|
|
12827
|
+
authority: (0, import_kit88.createNoopSigner)(authority),
|
|
12686
12828
|
usdMint,
|
|
12687
12829
|
amount
|
|
12688
12830
|
});
|
|
@@ -12694,7 +12836,7 @@ async function buildCreatePublicAutomationInstruction(authority, usdMint, strate
|
|
|
12694
12836
|
mint: usdMint
|
|
12695
12837
|
});
|
|
12696
12838
|
return await getCreatePublicAutomationInstructionAsync({
|
|
12697
|
-
authority: (0,
|
|
12839
|
+
authority: (0, import_kit88.createNoopSigner)(authority),
|
|
12698
12840
|
usdMint,
|
|
12699
12841
|
authorityUsdAta,
|
|
12700
12842
|
strategy,
|
|
@@ -12711,7 +12853,7 @@ async function buildTopUpPublicAutomationInstruction(authority, usdMint, amount)
|
|
|
12711
12853
|
mint: usdMint
|
|
12712
12854
|
});
|
|
12713
12855
|
return await getTopUpPublicAutomationInstructionAsync({
|
|
12714
|
-
authority: (0,
|
|
12856
|
+
authority: (0, import_kit88.createNoopSigner)(authority),
|
|
12715
12857
|
usdMint,
|
|
12716
12858
|
authorityUsdAta,
|
|
12717
12859
|
amount
|
|
@@ -12719,7 +12861,7 @@ async function buildTopUpPublicAutomationInstruction(authority, usdMint, amount)
|
|
|
12719
12861
|
}
|
|
12720
12862
|
async function buildCancelPublicAutomationInstruction(authority, usdMint) {
|
|
12721
12863
|
return await getCancelPublicAutomationInstructionAsync({
|
|
12722
|
-
authority: (0,
|
|
12864
|
+
authority: (0, import_kit88.createNoopSigner)(authority),
|
|
12723
12865
|
usdMint
|
|
12724
12866
|
});
|
|
12725
12867
|
}
|
|
@@ -12743,7 +12885,7 @@ async function buildExecutePublicAutomationInstruction(crankAuthority, automatio
|
|
|
12743
12885
|
]);
|
|
12744
12886
|
const [eventAuthority] = await getEventAuthorityAddress();
|
|
12745
12887
|
return await getExecutePublicAutomationInstructionAsync({
|
|
12746
|
-
authority: (0,
|
|
12888
|
+
authority: (0, import_kit88.createNoopSigner)(crankAuthority),
|
|
12747
12889
|
round,
|
|
12748
12890
|
publicAutomation,
|
|
12749
12891
|
usdMint,
|
|
@@ -12945,6 +13087,8 @@ function nextStreakMultiplier(currentStreakCount, lastMinedRoundId, nextRoundId)
|
|
|
12945
13087
|
SATRUSH_ERROR__INVALID_SELECTION_MASK,
|
|
12946
13088
|
SATRUSH_ERROR__INVALID_SHARE_AMOUNT,
|
|
12947
13089
|
SATRUSH_ERROR__INVALID_SLOT_HASH,
|
|
13090
|
+
SATRUSH_ERROR__INVALID_STRIKE_TRIGGER_MODULUS,
|
|
13091
|
+
SATRUSH_ERROR__INVALID_SWAP_BPS,
|
|
12948
13092
|
SATRUSH_ERROR__INVALID_SWAP_PROGRAM,
|
|
12949
13093
|
SATRUSH_ERROR__INVALID_TICKETS_COUNT,
|
|
12950
13094
|
SATRUSH_ERROR__INVALID_UNCLAIMED_HASHRATE_BPS,
|
|
@@ -12988,6 +13132,7 @@ function nextStreakMultiplier(currentStreakCount, lastMinedRoundId, nextRoundId)
|
|
|
12988
13132
|
UPDATE_DEPLOYMENT_SETTLE_GRACE_DURATION_DISCRIMINATOR,
|
|
12989
13133
|
UPDATE_EPOCH_VAULT_ITERATION_DURATION_DISCRIMINATOR,
|
|
12990
13134
|
UPDATE_MIN_DEPLOY_USD_AMOUNT_DISCRIMINATOR,
|
|
13135
|
+
UPDATE_STRIKE_TRIGGER_MODULUS_DISCRIMINATOR,
|
|
12991
13136
|
UPDATE_UNCLAIMED_HASHRATE_BPS_DISCRIMINATOR,
|
|
12992
13137
|
WITHDRAW_PROTOCOL_FEES_DISCRIMINATOR,
|
|
12993
13138
|
btcToSats,
|
|
@@ -13446,6 +13591,12 @@ function nextStreakMultiplier(currentStreakCount, lastMinedRoundId, nextRoundId)
|
|
|
13446
13591
|
getUpdateMinDeployUsdAmountInstructionDataCodec,
|
|
13447
13592
|
getUpdateMinDeployUsdAmountInstructionDataDecoder,
|
|
13448
13593
|
getUpdateMinDeployUsdAmountInstructionDataEncoder,
|
|
13594
|
+
getUpdateStrikeTriggerModulusDiscriminatorBytes,
|
|
13595
|
+
getUpdateStrikeTriggerModulusInstruction,
|
|
13596
|
+
getUpdateStrikeTriggerModulusInstructionAsync,
|
|
13597
|
+
getUpdateStrikeTriggerModulusInstructionDataCodec,
|
|
13598
|
+
getUpdateStrikeTriggerModulusInstructionDataDecoder,
|
|
13599
|
+
getUpdateStrikeTriggerModulusInstructionDataEncoder,
|
|
13449
13600
|
getUpdateUnclaimedHashrateBpsDiscriminatorBytes,
|
|
13450
13601
|
getUpdateUnclaimedHashrateBpsInstruction,
|
|
13451
13602
|
getUpdateUnclaimedHashrateBpsInstructionAsync,
|
|
@@ -13504,6 +13655,7 @@ function nextStreakMultiplier(currentStreakCount, lastMinedRoundId, nextRoundId)
|
|
|
13504
13655
|
parseUpdateDeploymentSettleGraceDurationInstruction,
|
|
13505
13656
|
parseUpdateEpochVaultIterationDurationInstruction,
|
|
13506
13657
|
parseUpdateMinDeployUsdAmountInstruction,
|
|
13658
|
+
parseUpdateStrikeTriggerModulusInstruction,
|
|
13507
13659
|
parseUpdateUnclaimedHashrateBpsInstruction,
|
|
13508
13660
|
parseWithdrawProtocolFeesInstruction,
|
|
13509
13661
|
satrushProgram,
|