From 5aacc12629915266bd07ccd005e7f2e38f779d56 Mon Sep 17 00:00:00 2001 From: Tommy Johnson Date: Tue, 11 Mar 2025 16:09:39 -0400 Subject: [PATCH] WIP client and tests --- Cargo.lock | 1 + .../instructions/adminRegisterStMint.ts | 2 +- .../instructions/adminSetConfigFees.ts | 2 +- .../instructions/adminSetNewAdmin.ts | 2 +- .../instructions/adminSetParameters.ts | 2 +- .../instructions/adminSetStMint.ts | 2 +- .../instructions/adminSetTieBreaker.ts | 2 +- .../instructions/adminSetWeight.ts | 2 +- .../instructions/claimWithPayer.ts | 2 +- .../instructions/closeEpochAccount.ts | 2 +- .../distributeBaseNcnRewardRoute.ts | 2 +- .../instructions/distributeBaseRewards.ts | 2 +- .../distributeNcnOperatorRewards.ts | 2 +- .../instructions/distributeNcnVaultRewards.ts | 2 +- .../js/jito_tip_router/instructions/index.ts | 1 + .../initializeBaseRewardRouter.ts | 2 +- .../instructions/initializeNcnRewardRouter.ts | 2 +- .../instructions/reallocBaseRewardRouter.ts | 2 +- .../instructions/routeBaseRewards.ts | 2 +- .../instructions/routeNcnRewards.ts | 2 +- .../instructions/setPriorityFeeMerkleRoot.ts | 316 ++++++++ .../jito_tip_router/programs/jitoTipRouter.ts | 42 +- .../instructions/admin_register_st_mint.rs | 2 +- .../instructions/admin_set_config_fees.rs | 2 +- .../instructions/admin_set_new_admin.rs | 2 +- .../instructions/admin_set_parameters.rs | 2 +- .../instructions/admin_set_st_mint.rs | 2 +- .../instructions/admin_set_tie_breaker.rs | 2 +- .../instructions/admin_set_weight.rs | 2 +- .../instructions/claim_with_payer.rs | 2 +- .../instructions/close_epoch_account.rs | 2 +- .../distribute_base_ncn_reward_route.rs | 2 +- .../instructions/distribute_base_rewards.rs | 2 +- .../distribute_ncn_operator_rewards.rs | 2 +- .../distribute_ncn_vault_rewards.rs | 2 +- .../initialize_base_reward_router.rs | 2 +- .../initialize_ncn_reward_router.rs | 2 +- .../src/generated/instructions/mod.rs | 2 + .../realloc_base_reward_router.rs | 2 +- .../instructions/route_base_rewards.rs | 2 +- .../instructions/route_ncn_rewards.rs | 2 +- .../set_priority_fee_merkle_root.rs | 696 ++++++++++++++++++ core/src/instruction.rs | 17 + idl/jito_tip_router.json | 119 ++- .../jito_priority_fee_distribution.so | Bin 0 -> 369072 bytes .../tests/fixtures/test_builder.rs | 6 + .../tests/fixtures/tip_router_client.rs | 92 ++- .../bpf/set_priority_fee_merkle_root.rs | 8 +- program/Cargo.toml | 1 + program/src/lib.rs | 20 + program/src/set_priority_fee_merkle_root.rs | 106 +++ 51 files changed, 1423 insertions(+), 76 deletions(-) create mode 100644 clients/js/jito_tip_router/instructions/setPriorityFeeMerkleRoot.ts create mode 100644 clients/rust/jito_tip_router/src/generated/instructions/set_priority_fee_merkle_root.rs create mode 100755 integration_tests/tests/fixtures/jito_priority_fee_distribution.so create mode 100644 program/src/set_priority_fee_merkle_root.rs diff --git a/Cargo.lock b/Cargo.lock index 82491739..daaf5da8 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3796,6 +3796,7 @@ dependencies = [ "const_str_to_pubkey", "jito-bytemuck", "jito-jsm-core", + "jito-priority-fee-distribution-sdk", "jito-restaking-core", "jito-restaking-program", "jito-restaking-sdk", diff --git a/clients/js/jito_tip_router/instructions/adminRegisterStMint.ts b/clients/js/jito_tip_router/instructions/adminRegisterStMint.ts index 66e905bc..0ea38080 100644 --- a/clients/js/jito_tip_router/instructions/adminRegisterStMint.ts +++ b/clients/js/jito_tip_router/instructions/adminRegisterStMint.ts @@ -40,7 +40,7 @@ import { import { JITO_TIP_ROUTER_PROGRAM_ADDRESS } from '../programs'; import { getAccountMetaFactory, type ResolvedAccount } from '../shared'; -export const ADMIN_REGISTER_ST_MINT_DISCRIMINATOR = 33; +export const ADMIN_REGISTER_ST_MINT_DISCRIMINATOR = 34; export function getAdminRegisterStMintDiscriminatorBytes() { return getU8Encoder().encode(ADMIN_REGISTER_ST_MINT_DISCRIMINATOR); diff --git a/clients/js/jito_tip_router/instructions/adminSetConfigFees.ts b/clients/js/jito_tip_router/instructions/adminSetConfigFees.ts index cb0def8e..da22f610 100644 --- a/clients/js/jito_tip_router/instructions/adminSetConfigFees.ts +++ b/clients/js/jito_tip_router/instructions/adminSetConfigFees.ts @@ -38,7 +38,7 @@ import { import { JITO_TIP_ROUTER_PROGRAM_ADDRESS } from '../programs'; import { getAccountMetaFactory, type ResolvedAccount } from '../shared'; -export const ADMIN_SET_CONFIG_FEES_DISCRIMINATOR = 29; +export const ADMIN_SET_CONFIG_FEES_DISCRIMINATOR = 30; export function getAdminSetConfigFeesDiscriminatorBytes() { return getU8Encoder().encode(ADMIN_SET_CONFIG_FEES_DISCRIMINATOR); diff --git a/clients/js/jito_tip_router/instructions/adminSetNewAdmin.ts b/clients/js/jito_tip_router/instructions/adminSetNewAdmin.ts index db85e3c6..5c7ac366 100644 --- a/clients/js/jito_tip_router/instructions/adminSetNewAdmin.ts +++ b/clients/js/jito_tip_router/instructions/adminSetNewAdmin.ts @@ -36,7 +36,7 @@ import { type ConfigAdminRoleArgs, } from '../types'; -export const ADMIN_SET_NEW_ADMIN_DISCRIMINATOR = 30; +export const ADMIN_SET_NEW_ADMIN_DISCRIMINATOR = 31; export function getAdminSetNewAdminDiscriminatorBytes() { return getU8Encoder().encode(ADMIN_SET_NEW_ADMIN_DISCRIMINATOR); diff --git a/clients/js/jito_tip_router/instructions/adminSetParameters.ts b/clients/js/jito_tip_router/instructions/adminSetParameters.ts index 72648cda..bbc9c5dd 100644 --- a/clients/js/jito_tip_router/instructions/adminSetParameters.ts +++ b/clients/js/jito_tip_router/instructions/adminSetParameters.ts @@ -36,7 +36,7 @@ import { import { JITO_TIP_ROUTER_PROGRAM_ADDRESS } from '../programs'; import { getAccountMetaFactory, type ResolvedAccount } from '../shared'; -export const ADMIN_SET_PARAMETERS_DISCRIMINATOR = 28; +export const ADMIN_SET_PARAMETERS_DISCRIMINATOR = 29; export function getAdminSetParametersDiscriminatorBytes() { return getU8Encoder().encode(ADMIN_SET_PARAMETERS_DISCRIMINATOR); diff --git a/clients/js/jito_tip_router/instructions/adminSetStMint.ts b/clients/js/jito_tip_router/instructions/adminSetStMint.ts index 9f305479..bf21bc23 100644 --- a/clients/js/jito_tip_router/instructions/adminSetStMint.ts +++ b/clients/js/jito_tip_router/instructions/adminSetStMint.ts @@ -40,7 +40,7 @@ import { import { JITO_TIP_ROUTER_PROGRAM_ADDRESS } from '../programs'; import { getAccountMetaFactory, type ResolvedAccount } from '../shared'; -export const ADMIN_SET_ST_MINT_DISCRIMINATOR = 34; +export const ADMIN_SET_ST_MINT_DISCRIMINATOR = 35; export function getAdminSetStMintDiscriminatorBytes() { return getU8Encoder().encode(ADMIN_SET_ST_MINT_DISCRIMINATOR); diff --git a/clients/js/jito_tip_router/instructions/adminSetTieBreaker.ts b/clients/js/jito_tip_router/instructions/adminSetTieBreaker.ts index 0df660e9..59b89390 100644 --- a/clients/js/jito_tip_router/instructions/adminSetTieBreaker.ts +++ b/clients/js/jito_tip_router/instructions/adminSetTieBreaker.ts @@ -37,7 +37,7 @@ import { import { JITO_TIP_ROUTER_PROGRAM_ADDRESS } from '../programs'; import { getAccountMetaFactory, type ResolvedAccount } from '../shared'; -export const ADMIN_SET_TIE_BREAKER_DISCRIMINATOR = 31; +export const ADMIN_SET_TIE_BREAKER_DISCRIMINATOR = 32; export function getAdminSetTieBreakerDiscriminatorBytes() { return getU8Encoder().encode(ADMIN_SET_TIE_BREAKER_DISCRIMINATOR); diff --git a/clients/js/jito_tip_router/instructions/adminSetWeight.ts b/clients/js/jito_tip_router/instructions/adminSetWeight.ts index b3e35090..4aca3ed9 100644 --- a/clients/js/jito_tip_router/instructions/adminSetWeight.ts +++ b/clients/js/jito_tip_router/instructions/adminSetWeight.ts @@ -36,7 +36,7 @@ import { import { JITO_TIP_ROUTER_PROGRAM_ADDRESS } from '../programs'; import { getAccountMetaFactory, type ResolvedAccount } from '../shared'; -export const ADMIN_SET_WEIGHT_DISCRIMINATOR = 32; +export const ADMIN_SET_WEIGHT_DISCRIMINATOR = 33; export function getAdminSetWeightDiscriminatorBytes() { return getU8Encoder().encode(ADMIN_SET_WEIGHT_DISCRIMINATOR); diff --git a/clients/js/jito_tip_router/instructions/claimWithPayer.ts b/clients/js/jito_tip_router/instructions/claimWithPayer.ts index f1b3aa97..784ea6a9 100644 --- a/clients/js/jito_tip_router/instructions/claimWithPayer.ts +++ b/clients/js/jito_tip_router/instructions/claimWithPayer.ts @@ -36,7 +36,7 @@ import { import { JITO_TIP_ROUTER_PROGRAM_ADDRESS } from '../programs'; import { getAccountMetaFactory, type ResolvedAccount } from '../shared'; -export const CLAIM_WITH_PAYER_DISCRIMINATOR = 26; +export const CLAIM_WITH_PAYER_DISCRIMINATOR = 27; export function getClaimWithPayerDiscriminatorBytes() { return getU8Encoder().encode(CLAIM_WITH_PAYER_DISCRIMINATOR); diff --git a/clients/js/jito_tip_router/instructions/closeEpochAccount.ts b/clients/js/jito_tip_router/instructions/closeEpochAccount.ts index 8e042ed8..dbe26656 100644 --- a/clients/js/jito_tip_router/instructions/closeEpochAccount.ts +++ b/clients/js/jito_tip_router/instructions/closeEpochAccount.ts @@ -29,7 +29,7 @@ import { import { JITO_TIP_ROUTER_PROGRAM_ADDRESS } from '../programs'; import { getAccountMetaFactory, type ResolvedAccount } from '../shared'; -export const CLOSE_EPOCH_ACCOUNT_DISCRIMINATOR = 27; +export const CLOSE_EPOCH_ACCOUNT_DISCRIMINATOR = 28; export function getCloseEpochAccountDiscriminatorBytes() { return getU8Encoder().encode(CLOSE_EPOCH_ACCOUNT_DISCRIMINATOR); diff --git a/clients/js/jito_tip_router/instructions/distributeBaseNcnRewardRoute.ts b/clients/js/jito_tip_router/instructions/distributeBaseNcnRewardRoute.ts index 1f14674e..6d236550 100644 --- a/clients/js/jito_tip_router/instructions/distributeBaseNcnRewardRoute.ts +++ b/clients/js/jito_tip_router/instructions/distributeBaseNcnRewardRoute.ts @@ -29,7 +29,7 @@ import { import { JITO_TIP_ROUTER_PROGRAM_ADDRESS } from '../programs'; import { getAccountMetaFactory, type ResolvedAccount } from '../shared'; -export const DISTRIBUTE_BASE_NCN_REWARD_ROUTE_DISCRIMINATOR = 23; +export const DISTRIBUTE_BASE_NCN_REWARD_ROUTE_DISCRIMINATOR = 24; export function getDistributeBaseNcnRewardRouteDiscriminatorBytes() { return getU8Encoder().encode(DISTRIBUTE_BASE_NCN_REWARD_ROUTE_DISCRIMINATOR); diff --git a/clients/js/jito_tip_router/instructions/distributeBaseRewards.ts b/clients/js/jito_tip_router/instructions/distributeBaseRewards.ts index d8f373a0..10d07ed5 100644 --- a/clients/js/jito_tip_router/instructions/distributeBaseRewards.ts +++ b/clients/js/jito_tip_router/instructions/distributeBaseRewards.ts @@ -29,7 +29,7 @@ import { import { JITO_TIP_ROUTER_PROGRAM_ADDRESS } from '../programs'; import { getAccountMetaFactory, type ResolvedAccount } from '../shared'; -export const DISTRIBUTE_BASE_REWARDS_DISCRIMINATOR = 22; +export const DISTRIBUTE_BASE_REWARDS_DISCRIMINATOR = 23; export function getDistributeBaseRewardsDiscriminatorBytes() { return getU8Encoder().encode(DISTRIBUTE_BASE_REWARDS_DISCRIMINATOR); diff --git a/clients/js/jito_tip_router/instructions/distributeNcnOperatorRewards.ts b/clients/js/jito_tip_router/instructions/distributeNcnOperatorRewards.ts index bcfa6270..5b3c068b 100644 --- a/clients/js/jito_tip_router/instructions/distributeNcnOperatorRewards.ts +++ b/clients/js/jito_tip_router/instructions/distributeNcnOperatorRewards.ts @@ -29,7 +29,7 @@ import { import { JITO_TIP_ROUTER_PROGRAM_ADDRESS } from '../programs'; import { getAccountMetaFactory, type ResolvedAccount } from '../shared'; -export const DISTRIBUTE_NCN_OPERATOR_REWARDS_DISCRIMINATOR = 24; +export const DISTRIBUTE_NCN_OPERATOR_REWARDS_DISCRIMINATOR = 25; export function getDistributeNcnOperatorRewardsDiscriminatorBytes() { return getU8Encoder().encode(DISTRIBUTE_NCN_OPERATOR_REWARDS_DISCRIMINATOR); diff --git a/clients/js/jito_tip_router/instructions/distributeNcnVaultRewards.ts b/clients/js/jito_tip_router/instructions/distributeNcnVaultRewards.ts index 7425f285..4f63c444 100644 --- a/clients/js/jito_tip_router/instructions/distributeNcnVaultRewards.ts +++ b/clients/js/jito_tip_router/instructions/distributeNcnVaultRewards.ts @@ -29,7 +29,7 @@ import { import { JITO_TIP_ROUTER_PROGRAM_ADDRESS } from '../programs'; import { getAccountMetaFactory, type ResolvedAccount } from '../shared'; -export const DISTRIBUTE_NCN_VAULT_REWARDS_DISCRIMINATOR = 25; +export const DISTRIBUTE_NCN_VAULT_REWARDS_DISCRIMINATOR = 26; export function getDistributeNcnVaultRewardsDiscriminatorBytes() { return getU8Encoder().encode(DISTRIBUTE_NCN_VAULT_REWARDS_DISCRIMINATOR); diff --git a/clients/js/jito_tip_router/instructions/index.ts b/clients/js/jito_tip_router/instructions/index.ts index 6bd52c83..bfe269d7 100644 --- a/clients/js/jito_tip_router/instructions/index.ts +++ b/clients/js/jito_tip_router/instructions/index.ts @@ -39,5 +39,6 @@ export * from './registerVault'; export * from './routeBaseRewards'; export * from './routeNcnRewards'; export * from './setMerkleRoot'; +export * from './setPriorityFeeMerkleRoot'; export * from './snapshotVaultOperatorDelegation'; export * from './switchboardSetWeight'; diff --git a/clients/js/jito_tip_router/instructions/initializeBaseRewardRouter.ts b/clients/js/jito_tip_router/instructions/initializeBaseRewardRouter.ts index e323775a..312183ff 100644 --- a/clients/js/jito_tip_router/instructions/initializeBaseRewardRouter.ts +++ b/clients/js/jito_tip_router/instructions/initializeBaseRewardRouter.ts @@ -29,7 +29,7 @@ import { import { JITO_TIP_ROUTER_PROGRAM_ADDRESS } from '../programs'; import { getAccountMetaFactory, type ResolvedAccount } from '../shared'; -export const INITIALIZE_BASE_REWARD_ROUTER_DISCRIMINATOR = 17; +export const INITIALIZE_BASE_REWARD_ROUTER_DISCRIMINATOR = 18; export function getInitializeBaseRewardRouterDiscriminatorBytes() { return getU8Encoder().encode(INITIALIZE_BASE_REWARD_ROUTER_DISCRIMINATOR); diff --git a/clients/js/jito_tip_router/instructions/initializeNcnRewardRouter.ts b/clients/js/jito_tip_router/instructions/initializeNcnRewardRouter.ts index 17940817..71332ef1 100644 --- a/clients/js/jito_tip_router/instructions/initializeNcnRewardRouter.ts +++ b/clients/js/jito_tip_router/instructions/initializeNcnRewardRouter.ts @@ -29,7 +29,7 @@ import { import { JITO_TIP_ROUTER_PROGRAM_ADDRESS } from '../programs'; import { getAccountMetaFactory, type ResolvedAccount } from '../shared'; -export const INITIALIZE_NCN_REWARD_ROUTER_DISCRIMINATOR = 19; +export const INITIALIZE_NCN_REWARD_ROUTER_DISCRIMINATOR = 20; export function getInitializeNcnRewardRouterDiscriminatorBytes() { return getU8Encoder().encode(INITIALIZE_NCN_REWARD_ROUTER_DISCRIMINATOR); diff --git a/clients/js/jito_tip_router/instructions/reallocBaseRewardRouter.ts b/clients/js/jito_tip_router/instructions/reallocBaseRewardRouter.ts index 561819a5..0f2b6904 100644 --- a/clients/js/jito_tip_router/instructions/reallocBaseRewardRouter.ts +++ b/clients/js/jito_tip_router/instructions/reallocBaseRewardRouter.ts @@ -29,7 +29,7 @@ import { import { JITO_TIP_ROUTER_PROGRAM_ADDRESS } from '../programs'; import { getAccountMetaFactory, type ResolvedAccount } from '../shared'; -export const REALLOC_BASE_REWARD_ROUTER_DISCRIMINATOR = 18; +export const REALLOC_BASE_REWARD_ROUTER_DISCRIMINATOR = 19; export function getReallocBaseRewardRouterDiscriminatorBytes() { return getU8Encoder().encode(REALLOC_BASE_REWARD_ROUTER_DISCRIMINATOR); diff --git a/clients/js/jito_tip_router/instructions/routeBaseRewards.ts b/clients/js/jito_tip_router/instructions/routeBaseRewards.ts index 0a9a77d1..b0e51f08 100644 --- a/clients/js/jito_tip_router/instructions/routeBaseRewards.ts +++ b/clients/js/jito_tip_router/instructions/routeBaseRewards.ts @@ -31,7 +31,7 @@ import { import { JITO_TIP_ROUTER_PROGRAM_ADDRESS } from '../programs'; import { getAccountMetaFactory, type ResolvedAccount } from '../shared'; -export const ROUTE_BASE_REWARDS_DISCRIMINATOR = 20; +export const ROUTE_BASE_REWARDS_DISCRIMINATOR = 21; export function getRouteBaseRewardsDiscriminatorBytes() { return getU8Encoder().encode(ROUTE_BASE_REWARDS_DISCRIMINATOR); diff --git a/clients/js/jito_tip_router/instructions/routeNcnRewards.ts b/clients/js/jito_tip_router/instructions/routeNcnRewards.ts index 1f22dc6a..ae5e3833 100644 --- a/clients/js/jito_tip_router/instructions/routeNcnRewards.ts +++ b/clients/js/jito_tip_router/instructions/routeNcnRewards.ts @@ -31,7 +31,7 @@ import { import { JITO_TIP_ROUTER_PROGRAM_ADDRESS } from '../programs'; import { getAccountMetaFactory, type ResolvedAccount } from '../shared'; -export const ROUTE_NCN_REWARDS_DISCRIMINATOR = 21; +export const ROUTE_NCN_REWARDS_DISCRIMINATOR = 22; export function getRouteNcnRewardsDiscriminatorBytes() { return getU8Encoder().encode(ROUTE_NCN_REWARDS_DISCRIMINATOR); diff --git a/clients/js/jito_tip_router/instructions/setPriorityFeeMerkleRoot.ts b/clients/js/jito_tip_router/instructions/setPriorityFeeMerkleRoot.ts new file mode 100644 index 00000000..9678ab0c --- /dev/null +++ b/clients/js/jito_tip_router/instructions/setPriorityFeeMerkleRoot.ts @@ -0,0 +1,316 @@ +/** + * This code was AUTOGENERATED using the kinobi library. + * Please DO NOT EDIT THIS FILE, instead use visitors + * to add features, then rerun kinobi to update it. + * + * @see https://github.com/kinobi-so/kinobi + */ + +import { + combineCodec, + fixDecoderSize, + fixEncoderSize, + getArrayDecoder, + getArrayEncoder, + getBytesDecoder, + getBytesEncoder, + getStructDecoder, + getStructEncoder, + getU64Decoder, + getU64Encoder, + getU8Decoder, + getU8Encoder, + transformEncoder, + type Address, + type Codec, + type Decoder, + type Encoder, + type IAccountMeta, + type IInstruction, + type IInstructionWithAccounts, + type IInstructionWithData, + type ReadonlyAccount, + type ReadonlyUint8Array, + type WritableAccount, +} from '@solana/web3.js'; +import { JITO_TIP_ROUTER_PROGRAM_ADDRESS } from '../programs'; +import { getAccountMetaFactory, type ResolvedAccount } from '../shared'; + +export const SET_PRIORITY_FEE_MERKLE_ROOT_DISCRIMINATOR = 17; + +export function getSetPriorityFeeMerkleRootDiscriminatorBytes() { + return getU8Encoder().encode(SET_PRIORITY_FEE_MERKLE_ROOT_DISCRIMINATOR); +} + +export type SetPriorityFeeMerkleRootInstruction< + TProgram extends string = typeof JITO_TIP_ROUTER_PROGRAM_ADDRESS, + TAccountEpochState extends string | IAccountMeta = string, + TAccountConfig extends string | IAccountMeta = string, + TAccountNcn extends string | IAccountMeta = string, + TAccountBallotBox extends string | IAccountMeta = string, + TAccountVoteAccount extends string | IAccountMeta = string, + TAccountTipDistributionAccount extends string | IAccountMeta = string, + TAccountTipDistributionConfig extends string | IAccountMeta = string, + TAccountPriorityFeeDistributionProgram extends + | string + | IAccountMeta = string, + TRemainingAccounts extends readonly IAccountMeta[] = [], +> = IInstruction & + IInstructionWithData & + IInstructionWithAccounts< + [ + TAccountEpochState extends string + ? WritableAccount + : TAccountEpochState, + TAccountConfig extends string + ? WritableAccount + : TAccountConfig, + TAccountNcn extends string ? ReadonlyAccount : TAccountNcn, + TAccountBallotBox extends string + ? ReadonlyAccount + : TAccountBallotBox, + TAccountVoteAccount extends string + ? ReadonlyAccount + : TAccountVoteAccount, + TAccountTipDistributionAccount extends string + ? WritableAccount + : TAccountTipDistributionAccount, + TAccountTipDistributionConfig extends string + ? ReadonlyAccount + : TAccountTipDistributionConfig, + TAccountPriorityFeeDistributionProgram extends string + ? ReadonlyAccount + : TAccountPriorityFeeDistributionProgram, + ...TRemainingAccounts, + ] + >; + +export type SetPriorityFeeMerkleRootInstructionData = { + discriminator: number; + proof: Array; + merkleRoot: ReadonlyUint8Array; + maxTotalClaim: bigint; + maxNumNodes: bigint; + epoch: bigint; +}; + +export type SetPriorityFeeMerkleRootInstructionDataArgs = { + proof: Array; + merkleRoot: ReadonlyUint8Array; + maxTotalClaim: number | bigint; + maxNumNodes: number | bigint; + epoch: number | bigint; +}; + +export function getSetPriorityFeeMerkleRootInstructionDataEncoder(): Encoder { + return transformEncoder( + getStructEncoder([ + ['discriminator', getU8Encoder()], + ['proof', getArrayEncoder(fixEncoderSize(getBytesEncoder(), 32))], + ['merkleRoot', fixEncoderSize(getBytesEncoder(), 32)], + ['maxTotalClaim', getU64Encoder()], + ['maxNumNodes', getU64Encoder()], + ['epoch', getU64Encoder()], + ]), + (value) => ({ + ...value, + discriminator: SET_PRIORITY_FEE_MERKLE_ROOT_DISCRIMINATOR, + }) + ); +} + +export function getSetPriorityFeeMerkleRootInstructionDataDecoder(): Decoder { + return getStructDecoder([ + ['discriminator', getU8Decoder()], + ['proof', getArrayDecoder(fixDecoderSize(getBytesDecoder(), 32))], + ['merkleRoot', fixDecoderSize(getBytesDecoder(), 32)], + ['maxTotalClaim', getU64Decoder()], + ['maxNumNodes', getU64Decoder()], + ['epoch', getU64Decoder()], + ]); +} + +export function getSetPriorityFeeMerkleRootInstructionDataCodec(): Codec< + SetPriorityFeeMerkleRootInstructionDataArgs, + SetPriorityFeeMerkleRootInstructionData +> { + return combineCodec( + getSetPriorityFeeMerkleRootInstructionDataEncoder(), + getSetPriorityFeeMerkleRootInstructionDataDecoder() + ); +} + +export type SetPriorityFeeMerkleRootInput< + TAccountEpochState extends string = string, + TAccountConfig extends string = string, + TAccountNcn extends string = string, + TAccountBallotBox extends string = string, + TAccountVoteAccount extends string = string, + TAccountTipDistributionAccount extends string = string, + TAccountTipDistributionConfig extends string = string, + TAccountPriorityFeeDistributionProgram extends string = string, +> = { + epochState: Address; + config: Address; + ncn: Address; + ballotBox: Address; + voteAccount: Address; + tipDistributionAccount: Address; + tipDistributionConfig: Address; + priorityFeeDistributionProgram: Address; + proof: SetPriorityFeeMerkleRootInstructionDataArgs['proof']; + merkleRoot: SetPriorityFeeMerkleRootInstructionDataArgs['merkleRoot']; + maxTotalClaim: SetPriorityFeeMerkleRootInstructionDataArgs['maxTotalClaim']; + maxNumNodes: SetPriorityFeeMerkleRootInstructionDataArgs['maxNumNodes']; + epoch: SetPriorityFeeMerkleRootInstructionDataArgs['epoch']; +}; + +export function getSetPriorityFeeMerkleRootInstruction< + TAccountEpochState extends string, + TAccountConfig extends string, + TAccountNcn extends string, + TAccountBallotBox extends string, + TAccountVoteAccount extends string, + TAccountTipDistributionAccount extends string, + TAccountTipDistributionConfig extends string, + TAccountPriorityFeeDistributionProgram extends string, + TProgramAddress extends Address = typeof JITO_TIP_ROUTER_PROGRAM_ADDRESS, +>( + input: SetPriorityFeeMerkleRootInput< + TAccountEpochState, + TAccountConfig, + TAccountNcn, + TAccountBallotBox, + TAccountVoteAccount, + TAccountTipDistributionAccount, + TAccountTipDistributionConfig, + TAccountPriorityFeeDistributionProgram + >, + config?: { programAddress?: TProgramAddress } +): SetPriorityFeeMerkleRootInstruction< + TProgramAddress, + TAccountEpochState, + TAccountConfig, + TAccountNcn, + TAccountBallotBox, + TAccountVoteAccount, + TAccountTipDistributionAccount, + TAccountTipDistributionConfig, + TAccountPriorityFeeDistributionProgram +> { + // Program address. + const programAddress = + config?.programAddress ?? JITO_TIP_ROUTER_PROGRAM_ADDRESS; + + // Original accounts. + const originalAccounts = { + epochState: { value: input.epochState ?? null, isWritable: true }, + config: { value: input.config ?? null, isWritable: true }, + ncn: { value: input.ncn ?? null, isWritable: false }, + ballotBox: { value: input.ballotBox ?? null, isWritable: false }, + voteAccount: { value: input.voteAccount ?? null, isWritable: false }, + tipDistributionAccount: { + value: input.tipDistributionAccount ?? null, + isWritable: true, + }, + tipDistributionConfig: { + value: input.tipDistributionConfig ?? null, + isWritable: false, + }, + priorityFeeDistributionProgram: { + value: input.priorityFeeDistributionProgram ?? null, + isWritable: false, + }, + }; + const accounts = originalAccounts as Record< + keyof typeof originalAccounts, + ResolvedAccount + >; + + // Original args. + const args = { ...input }; + + const getAccountMeta = getAccountMetaFactory(programAddress, 'programId'); + const instruction = { + accounts: [ + getAccountMeta(accounts.epochState), + getAccountMeta(accounts.config), + getAccountMeta(accounts.ncn), + getAccountMeta(accounts.ballotBox), + getAccountMeta(accounts.voteAccount), + getAccountMeta(accounts.tipDistributionAccount), + getAccountMeta(accounts.tipDistributionConfig), + getAccountMeta(accounts.priorityFeeDistributionProgram), + ], + programAddress, + data: getSetPriorityFeeMerkleRootInstructionDataEncoder().encode( + args as SetPriorityFeeMerkleRootInstructionDataArgs + ), + } as SetPriorityFeeMerkleRootInstruction< + TProgramAddress, + TAccountEpochState, + TAccountConfig, + TAccountNcn, + TAccountBallotBox, + TAccountVoteAccount, + TAccountTipDistributionAccount, + TAccountTipDistributionConfig, + TAccountPriorityFeeDistributionProgram + >; + + return instruction; +} + +export type ParsedSetPriorityFeeMerkleRootInstruction< + TProgram extends string = typeof JITO_TIP_ROUTER_PROGRAM_ADDRESS, + TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[], +> = { + programAddress: Address; + accounts: { + epochState: TAccountMetas[0]; + config: TAccountMetas[1]; + ncn: TAccountMetas[2]; + ballotBox: TAccountMetas[3]; + voteAccount: TAccountMetas[4]; + tipDistributionAccount: TAccountMetas[5]; + tipDistributionConfig: TAccountMetas[6]; + priorityFeeDistributionProgram: TAccountMetas[7]; + }; + data: SetPriorityFeeMerkleRootInstructionData; +}; + +export function parseSetPriorityFeeMerkleRootInstruction< + TProgram extends string, + TAccountMetas extends readonly IAccountMeta[], +>( + instruction: IInstruction & + IInstructionWithAccounts & + IInstructionWithData +): ParsedSetPriorityFeeMerkleRootInstruction { + if (instruction.accounts.length < 8) { + // TODO: Coded error. + throw new Error('Not enough accounts'); + } + let accountIndex = 0; + const getNextAccount = () => { + const accountMeta = instruction.accounts![accountIndex]!; + accountIndex += 1; + return accountMeta; + }; + return { + programAddress: instruction.programAddress, + accounts: { + epochState: getNextAccount(), + config: getNextAccount(), + ncn: getNextAccount(), + ballotBox: getNextAccount(), + voteAccount: getNextAccount(), + tipDistributionAccount: getNextAccount(), + tipDistributionConfig: getNextAccount(), + priorityFeeDistributionProgram: getNextAccount(), + }, + data: getSetPriorityFeeMerkleRootInstructionDataDecoder().decode( + instruction.data + ), + }; +} diff --git a/clients/js/jito_tip_router/programs/jitoTipRouter.ts b/clients/js/jito_tip_router/programs/jitoTipRouter.ts index 3d833032..77794fe0 100644 --- a/clients/js/jito_tip_router/programs/jitoTipRouter.ts +++ b/clients/js/jito_tip_router/programs/jitoTipRouter.ts @@ -46,6 +46,7 @@ import { type ParsedRouteBaseRewardsInstruction, type ParsedRouteNcnRewardsInstruction, type ParsedSetMerkleRootInstruction, + type ParsedSetPriorityFeeMerkleRootInstruction, type ParsedSnapshotVaultOperatorDelegationInstruction, type ParsedSwitchboardSetWeightInstruction, } from '../instructions'; @@ -84,6 +85,7 @@ export enum JitoTipRouterInstruction { ReallocBallotBox, CastVote, SetMerkleRoot, + SetPriorityFeeMerkleRoot, InitializeBaseRewardRouter, ReallocBaseRewardRouter, InitializeNcnRewardRouter, @@ -160,57 +162,60 @@ export function identifyJitoTipRouterInstruction( return JitoTipRouterInstruction.SetMerkleRoot; } if (containsBytes(data, getU8Encoder().encode(17), 0)) { - return JitoTipRouterInstruction.InitializeBaseRewardRouter; + return JitoTipRouterInstruction.SetPriorityFeeMerkleRoot; } if (containsBytes(data, getU8Encoder().encode(18), 0)) { - return JitoTipRouterInstruction.ReallocBaseRewardRouter; + return JitoTipRouterInstruction.InitializeBaseRewardRouter; } if (containsBytes(data, getU8Encoder().encode(19), 0)) { - return JitoTipRouterInstruction.InitializeNcnRewardRouter; + return JitoTipRouterInstruction.ReallocBaseRewardRouter; } if (containsBytes(data, getU8Encoder().encode(20), 0)) { - return JitoTipRouterInstruction.RouteBaseRewards; + return JitoTipRouterInstruction.InitializeNcnRewardRouter; } if (containsBytes(data, getU8Encoder().encode(21), 0)) { - return JitoTipRouterInstruction.RouteNcnRewards; + return JitoTipRouterInstruction.RouteBaseRewards; } if (containsBytes(data, getU8Encoder().encode(22), 0)) { - return JitoTipRouterInstruction.DistributeBaseRewards; + return JitoTipRouterInstruction.RouteNcnRewards; } if (containsBytes(data, getU8Encoder().encode(23), 0)) { - return JitoTipRouterInstruction.DistributeBaseNcnRewardRoute; + return JitoTipRouterInstruction.DistributeBaseRewards; } if (containsBytes(data, getU8Encoder().encode(24), 0)) { - return JitoTipRouterInstruction.DistributeNcnOperatorRewards; + return JitoTipRouterInstruction.DistributeBaseNcnRewardRoute; } if (containsBytes(data, getU8Encoder().encode(25), 0)) { - return JitoTipRouterInstruction.DistributeNcnVaultRewards; + return JitoTipRouterInstruction.DistributeNcnOperatorRewards; } if (containsBytes(data, getU8Encoder().encode(26), 0)) { - return JitoTipRouterInstruction.ClaimWithPayer; + return JitoTipRouterInstruction.DistributeNcnVaultRewards; } if (containsBytes(data, getU8Encoder().encode(27), 0)) { - return JitoTipRouterInstruction.CloseEpochAccount; + return JitoTipRouterInstruction.ClaimWithPayer; } if (containsBytes(data, getU8Encoder().encode(28), 0)) { - return JitoTipRouterInstruction.AdminSetParameters; + return JitoTipRouterInstruction.CloseEpochAccount; } if (containsBytes(data, getU8Encoder().encode(29), 0)) { - return JitoTipRouterInstruction.AdminSetConfigFees; + return JitoTipRouterInstruction.AdminSetParameters; } if (containsBytes(data, getU8Encoder().encode(30), 0)) { - return JitoTipRouterInstruction.AdminSetNewAdmin; + return JitoTipRouterInstruction.AdminSetConfigFees; } if (containsBytes(data, getU8Encoder().encode(31), 0)) { - return JitoTipRouterInstruction.AdminSetTieBreaker; + return JitoTipRouterInstruction.AdminSetNewAdmin; } if (containsBytes(data, getU8Encoder().encode(32), 0)) { - return JitoTipRouterInstruction.AdminSetWeight; + return JitoTipRouterInstruction.AdminSetTieBreaker; } if (containsBytes(data, getU8Encoder().encode(33), 0)) { - return JitoTipRouterInstruction.AdminRegisterStMint; + return JitoTipRouterInstruction.AdminSetWeight; } if (containsBytes(data, getU8Encoder().encode(34), 0)) { + return JitoTipRouterInstruction.AdminRegisterStMint; + } + if (containsBytes(data, getU8Encoder().encode(35), 0)) { return JitoTipRouterInstruction.AdminSetStMint; } throw new Error( @@ -272,6 +277,9 @@ export type ParsedJitoTipRouterInstruction< | ({ instructionType: JitoTipRouterInstruction.SetMerkleRoot; } & ParsedSetMerkleRootInstruction) + | ({ + instructionType: JitoTipRouterInstruction.SetPriorityFeeMerkleRoot; + } & ParsedSetPriorityFeeMerkleRootInstruction) | ({ instructionType: JitoTipRouterInstruction.InitializeBaseRewardRouter; } & ParsedInitializeBaseRewardRouterInstruction) diff --git a/clients/rust/jito_tip_router/src/generated/instructions/admin_register_st_mint.rs b/clients/rust/jito_tip_router/src/generated/instructions/admin_register_st_mint.rs index 2250faca..93e66fcb 100644 --- a/clients/rust/jito_tip_router/src/generated/instructions/admin_register_st_mint.rs +++ b/clients/rust/jito_tip_router/src/generated/instructions/admin_register_st_mint.rs @@ -76,7 +76,7 @@ pub struct AdminRegisterStMintInstructionData { impl AdminRegisterStMintInstructionData { pub fn new() -> Self { - Self { discriminator: 33 } + Self { discriminator: 34 } } } diff --git a/clients/rust/jito_tip_router/src/generated/instructions/admin_set_config_fees.rs b/clients/rust/jito_tip_router/src/generated/instructions/admin_set_config_fees.rs index ad3ce48c..427b4b96 100644 --- a/clients/rust/jito_tip_router/src/generated/instructions/admin_set_config_fees.rs +++ b/clients/rust/jito_tip_router/src/generated/instructions/admin_set_config_fees.rs @@ -65,7 +65,7 @@ pub struct AdminSetConfigFeesInstructionData { impl AdminSetConfigFeesInstructionData { pub fn new() -> Self { - Self { discriminator: 29 } + Self { discriminator: 30 } } } diff --git a/clients/rust/jito_tip_router/src/generated/instructions/admin_set_new_admin.rs b/clients/rust/jito_tip_router/src/generated/instructions/admin_set_new_admin.rs index 9a5c495f..9e2e656d 100644 --- a/clients/rust/jito_tip_router/src/generated/instructions/admin_set_new_admin.rs +++ b/clients/rust/jito_tip_router/src/generated/instructions/admin_set_new_admin.rs @@ -69,7 +69,7 @@ pub struct AdminSetNewAdminInstructionData { impl AdminSetNewAdminInstructionData { pub fn new() -> Self { - Self { discriminator: 30 } + Self { discriminator: 31 } } } diff --git a/clients/rust/jito_tip_router/src/generated/instructions/admin_set_parameters.rs b/clients/rust/jito_tip_router/src/generated/instructions/admin_set_parameters.rs index 2ed1977c..ad46ff66 100644 --- a/clients/rust/jito_tip_router/src/generated/instructions/admin_set_parameters.rs +++ b/clients/rust/jito_tip_router/src/generated/instructions/admin_set_parameters.rs @@ -64,7 +64,7 @@ pub struct AdminSetParametersInstructionData { impl AdminSetParametersInstructionData { pub fn new() -> Self { - Self { discriminator: 28 } + Self { discriminator: 29 } } } diff --git a/clients/rust/jito_tip_router/src/generated/instructions/admin_set_st_mint.rs b/clients/rust/jito_tip_router/src/generated/instructions/admin_set_st_mint.rs index f7838f4a..5ac560db 100644 --- a/clients/rust/jito_tip_router/src/generated/instructions/admin_set_st_mint.rs +++ b/clients/rust/jito_tip_router/src/generated/instructions/admin_set_st_mint.rs @@ -68,7 +68,7 @@ pub struct AdminSetStMintInstructionData { impl AdminSetStMintInstructionData { pub fn new() -> Self { - Self { discriminator: 34 } + Self { discriminator: 35 } } } diff --git a/clients/rust/jito_tip_router/src/generated/instructions/admin_set_tie_breaker.rs b/clients/rust/jito_tip_router/src/generated/instructions/admin_set_tie_breaker.rs index 6fc2ce2a..b78dce80 100644 --- a/clients/rust/jito_tip_router/src/generated/instructions/admin_set_tie_breaker.rs +++ b/clients/rust/jito_tip_router/src/generated/instructions/admin_set_tie_breaker.rs @@ -76,7 +76,7 @@ pub struct AdminSetTieBreakerInstructionData { impl AdminSetTieBreakerInstructionData { pub fn new() -> Self { - Self { discriminator: 31 } + Self { discriminator: 32 } } } diff --git a/clients/rust/jito_tip_router/src/generated/instructions/admin_set_weight.rs b/clients/rust/jito_tip_router/src/generated/instructions/admin_set_weight.rs index 412f0926..a6e365fd 100644 --- a/clients/rust/jito_tip_router/src/generated/instructions/admin_set_weight.rs +++ b/clients/rust/jito_tip_router/src/generated/instructions/admin_set_weight.rs @@ -69,7 +69,7 @@ pub struct AdminSetWeightInstructionData { impl AdminSetWeightInstructionData { pub fn new() -> Self { - Self { discriminator: 32 } + Self { discriminator: 33 } } } diff --git a/clients/rust/jito_tip_router/src/generated/instructions/claim_with_payer.rs b/clients/rust/jito_tip_router/src/generated/instructions/claim_with_payer.rs index a5e1fcc2..c720cd88 100644 --- a/clients/rust/jito_tip_router/src/generated/instructions/claim_with_payer.rs +++ b/clients/rust/jito_tip_router/src/generated/instructions/claim_with_payer.rs @@ -98,7 +98,7 @@ pub struct ClaimWithPayerInstructionData { impl ClaimWithPayerInstructionData { pub fn new() -> Self { - Self { discriminator: 26 } + Self { discriminator: 27 } } } diff --git a/clients/rust/jito_tip_router/src/generated/instructions/close_epoch_account.rs b/clients/rust/jito_tip_router/src/generated/instructions/close_epoch_account.rs index c7f8e829..e77f395b 100644 --- a/clients/rust/jito_tip_router/src/generated/instructions/close_epoch_account.rs +++ b/clients/rust/jito_tip_router/src/generated/instructions/close_epoch_account.rs @@ -107,7 +107,7 @@ pub struct CloseEpochAccountInstructionData { impl CloseEpochAccountInstructionData { pub fn new() -> Self { - Self { discriminator: 27 } + Self { discriminator: 28 } } } diff --git a/clients/rust/jito_tip_router/src/generated/instructions/distribute_base_ncn_reward_route.rs b/clients/rust/jito_tip_router/src/generated/instructions/distribute_base_ncn_reward_route.rs index 3c9174b1..938b6568 100644 --- a/clients/rust/jito_tip_router/src/generated/instructions/distribute_base_ncn_reward_route.rs +++ b/clients/rust/jito_tip_router/src/generated/instructions/distribute_base_ncn_reward_route.rs @@ -100,7 +100,7 @@ pub struct DistributeBaseNcnRewardRouteInstructionData { impl DistributeBaseNcnRewardRouteInstructionData { pub fn new() -> Self { - Self { discriminator: 23 } + Self { discriminator: 24 } } } diff --git a/clients/rust/jito_tip_router/src/generated/instructions/distribute_base_rewards.rs b/clients/rust/jito_tip_router/src/generated/instructions/distribute_base_rewards.rs index 5229a333..42321002 100644 --- a/clients/rust/jito_tip_router/src/generated/instructions/distribute_base_rewards.rs +++ b/clients/rust/jito_tip_router/src/generated/instructions/distribute_base_rewards.rs @@ -142,7 +142,7 @@ pub struct DistributeBaseRewardsInstructionData { impl DistributeBaseRewardsInstructionData { pub fn new() -> Self { - Self { discriminator: 22 } + Self { discriminator: 23 } } } diff --git a/clients/rust/jito_tip_router/src/generated/instructions/distribute_ncn_operator_rewards.rs b/clients/rust/jito_tip_router/src/generated/instructions/distribute_ncn_operator_rewards.rs index b5cc877c..f673beb2 100644 --- a/clients/rust/jito_tip_router/src/generated/instructions/distribute_ncn_operator_rewards.rs +++ b/clients/rust/jito_tip_router/src/generated/instructions/distribute_ncn_operator_rewards.rs @@ -148,7 +148,7 @@ pub struct DistributeNcnOperatorRewardsInstructionData { impl DistributeNcnOperatorRewardsInstructionData { pub fn new() -> Self { - Self { discriminator: 24 } + Self { discriminator: 25 } } } diff --git a/clients/rust/jito_tip_router/src/generated/instructions/distribute_ncn_vault_rewards.rs b/clients/rust/jito_tip_router/src/generated/instructions/distribute_ncn_vault_rewards.rs index 3047fbc4..905566a2 100644 --- a/clients/rust/jito_tip_router/src/generated/instructions/distribute_ncn_vault_rewards.rs +++ b/clients/rust/jito_tip_router/src/generated/instructions/distribute_ncn_vault_rewards.rs @@ -153,7 +153,7 @@ pub struct DistributeNcnVaultRewardsInstructionData { impl DistributeNcnVaultRewardsInstructionData { pub fn new() -> Self { - Self { discriminator: 25 } + Self { discriminator: 26 } } } diff --git a/clients/rust/jito_tip_router/src/generated/instructions/initialize_base_reward_router.rs b/clients/rust/jito_tip_router/src/generated/instructions/initialize_base_reward_router.rs index 7eb146c3..b7e52bc5 100644 --- a/clients/rust/jito_tip_router/src/generated/instructions/initialize_base_reward_router.rs +++ b/clients/rust/jito_tip_router/src/generated/instructions/initialize_base_reward_router.rs @@ -88,7 +88,7 @@ pub struct InitializeBaseRewardRouterInstructionData { impl InitializeBaseRewardRouterInstructionData { pub fn new() -> Self { - Self { discriminator: 17 } + Self { discriminator: 18 } } } diff --git a/clients/rust/jito_tip_router/src/generated/instructions/initialize_ncn_reward_router.rs b/clients/rust/jito_tip_router/src/generated/instructions/initialize_ncn_reward_router.rs index 4311b22f..7a5ac9cc 100644 --- a/clients/rust/jito_tip_router/src/generated/instructions/initialize_ncn_reward_router.rs +++ b/clients/rust/jito_tip_router/src/generated/instructions/initialize_ncn_reward_router.rs @@ -100,7 +100,7 @@ pub struct InitializeNcnRewardRouterInstructionData { impl InitializeNcnRewardRouterInstructionData { pub fn new() -> Self { - Self { discriminator: 19 } + Self { discriminator: 20 } } } diff --git a/clients/rust/jito_tip_router/src/generated/instructions/mod.rs b/clients/rust/jito_tip_router/src/generated/instructions/mod.rs index acc33976..6a800c79 100644 --- a/clients/rust/jito_tip_router/src/generated/instructions/mod.rs +++ b/clients/rust/jito_tip_router/src/generated/instructions/mod.rs @@ -38,6 +38,7 @@ pub(crate) mod r#register_vault; pub(crate) mod r#route_base_rewards; pub(crate) mod r#route_ncn_rewards; pub(crate) mod r#set_merkle_root; +pub(crate) mod r#set_priority_fee_merkle_root; pub(crate) mod r#snapshot_vault_operator_delegation; pub(crate) mod r#switchboard_set_weight; @@ -74,5 +75,6 @@ pub use self::r#register_vault::*; pub use self::r#route_base_rewards::*; pub use self::r#route_ncn_rewards::*; pub use self::r#set_merkle_root::*; +pub use self::r#set_priority_fee_merkle_root::*; pub use self::r#snapshot_vault_operator_delegation::*; pub use self::r#switchboard_set_weight::*; diff --git a/clients/rust/jito_tip_router/src/generated/instructions/realloc_base_reward_router.rs b/clients/rust/jito_tip_router/src/generated/instructions/realloc_base_reward_router.rs index 70435d24..a39e19e2 100644 --- a/clients/rust/jito_tip_router/src/generated/instructions/realloc_base_reward_router.rs +++ b/clients/rust/jito_tip_router/src/generated/instructions/realloc_base_reward_router.rs @@ -82,7 +82,7 @@ pub struct ReallocBaseRewardRouterInstructionData { impl ReallocBaseRewardRouterInstructionData { pub fn new() -> Self { - Self { discriminator: 18 } + Self { discriminator: 19 } } } diff --git a/clients/rust/jito_tip_router/src/generated/instructions/route_base_rewards.rs b/clients/rust/jito_tip_router/src/generated/instructions/route_base_rewards.rs index 136aeea5..edc2c2d2 100644 --- a/clients/rust/jito_tip_router/src/generated/instructions/route_base_rewards.rs +++ b/clients/rust/jito_tip_router/src/generated/instructions/route_base_rewards.rs @@ -86,7 +86,7 @@ pub struct RouteBaseRewardsInstructionData { impl RouteBaseRewardsInstructionData { pub fn new() -> Self { - Self { discriminator: 20 } + Self { discriminator: 21 } } } diff --git a/clients/rust/jito_tip_router/src/generated/instructions/route_ncn_rewards.rs b/clients/rust/jito_tip_router/src/generated/instructions/route_ncn_rewards.rs index a4c3248b..6fb5916f 100644 --- a/clients/rust/jito_tip_router/src/generated/instructions/route_ncn_rewards.rs +++ b/clients/rust/jito_tip_router/src/generated/instructions/route_ncn_rewards.rs @@ -80,7 +80,7 @@ pub struct RouteNcnRewardsInstructionData { impl RouteNcnRewardsInstructionData { pub fn new() -> Self { - Self { discriminator: 21 } + Self { discriminator: 22 } } } diff --git a/clients/rust/jito_tip_router/src/generated/instructions/set_priority_fee_merkle_root.rs b/clients/rust/jito_tip_router/src/generated/instructions/set_priority_fee_merkle_root.rs new file mode 100644 index 00000000..c9baf9d8 --- /dev/null +++ b/clients/rust/jito_tip_router/src/generated/instructions/set_priority_fee_merkle_root.rs @@ -0,0 +1,696 @@ +//! This code was AUTOGENERATED using the kinobi library. +//! Please DO NOT EDIT THIS FILE, instead use visitors +//! to add features, then rerun kinobi to update it. +//! +//! +//! + +use borsh::BorshDeserialize; +use borsh::BorshSerialize; + +/// Accounts. +pub struct SetPriorityFeeMerkleRoot { + pub epoch_state: solana_program::pubkey::Pubkey, + + pub config: solana_program::pubkey::Pubkey, + + pub ncn: solana_program::pubkey::Pubkey, + + pub ballot_box: solana_program::pubkey::Pubkey, + + pub vote_account: solana_program::pubkey::Pubkey, + + pub tip_distribution_account: solana_program::pubkey::Pubkey, + + pub tip_distribution_config: solana_program::pubkey::Pubkey, + + pub priority_fee_distribution_program: solana_program::pubkey::Pubkey, +} + +impl SetPriorityFeeMerkleRoot { + pub fn instruction( + &self, + args: SetPriorityFeeMerkleRootInstructionArgs, + ) -> solana_program::instruction::Instruction { + self.instruction_with_remaining_accounts(args, &[]) + } + #[allow(clippy::vec_init_then_push)] + pub fn instruction_with_remaining_accounts( + &self, + args: SetPriorityFeeMerkleRootInstructionArgs, + remaining_accounts: &[solana_program::instruction::AccountMeta], + ) -> solana_program::instruction::Instruction { + let mut accounts = Vec::with_capacity(8 + remaining_accounts.len()); + accounts.push(solana_program::instruction::AccountMeta::new( + self.epoch_state, + false, + )); + accounts.push(solana_program::instruction::AccountMeta::new( + self.config, + false, + )); + accounts.push(solana_program::instruction::AccountMeta::new_readonly( + self.ncn, false, + )); + accounts.push(solana_program::instruction::AccountMeta::new_readonly( + self.ballot_box, + false, + )); + accounts.push(solana_program::instruction::AccountMeta::new_readonly( + self.vote_account, + false, + )); + accounts.push(solana_program::instruction::AccountMeta::new( + self.tip_distribution_account, + false, + )); + accounts.push(solana_program::instruction::AccountMeta::new_readonly( + self.tip_distribution_config, + false, + )); + accounts.push(solana_program::instruction::AccountMeta::new_readonly( + self.priority_fee_distribution_program, + false, + )); + accounts.extend_from_slice(remaining_accounts); + let mut data = SetPriorityFeeMerkleRootInstructionData::new() + .try_to_vec() + .unwrap(); + let mut args = args.try_to_vec().unwrap(); + data.append(&mut args); + + solana_program::instruction::Instruction { + program_id: crate::JITO_TIP_ROUTER_ID, + accounts, + data, + } + } +} + +#[derive(BorshDeserialize, BorshSerialize)] +pub struct SetPriorityFeeMerkleRootInstructionData { + discriminator: u8, +} + +impl SetPriorityFeeMerkleRootInstructionData { + pub fn new() -> Self { + Self { discriminator: 17 } + } +} + +impl Default for SetPriorityFeeMerkleRootInstructionData { + fn default() -> Self { + Self::new() + } +} + +#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)] +#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] +pub struct SetPriorityFeeMerkleRootInstructionArgs { + pub proof: Vec<[u8; 32]>, + pub merkle_root: [u8; 32], + pub max_total_claim: u64, + pub max_num_nodes: u64, + pub epoch: u64, +} + +/// Instruction builder for `SetPriorityFeeMerkleRoot`. +/// +/// ### Accounts: +/// +/// 0. `[writable]` epoch_state +/// 1. `[writable]` config +/// 2. `[]` ncn +/// 3. `[]` ballot_box +/// 4. `[]` vote_account +/// 5. `[writable]` tip_distribution_account +/// 6. `[]` tip_distribution_config +/// 7. `[]` priority_fee_distribution_program +#[derive(Clone, Debug, Default)] +pub struct SetPriorityFeeMerkleRootBuilder { + epoch_state: Option, + config: Option, + ncn: Option, + ballot_box: Option, + vote_account: Option, + tip_distribution_account: Option, + tip_distribution_config: Option, + priority_fee_distribution_program: Option, + proof: Option>, + merkle_root: Option<[u8; 32]>, + max_total_claim: Option, + max_num_nodes: Option, + epoch: Option, + __remaining_accounts: Vec, +} + +impl SetPriorityFeeMerkleRootBuilder { + pub fn new() -> Self { + Self::default() + } + #[inline(always)] + pub fn epoch_state(&mut self, epoch_state: solana_program::pubkey::Pubkey) -> &mut Self { + self.epoch_state = Some(epoch_state); + self + } + #[inline(always)] + pub fn config(&mut self, config: solana_program::pubkey::Pubkey) -> &mut Self { + self.config = Some(config); + self + } + #[inline(always)] + pub fn ncn(&mut self, ncn: solana_program::pubkey::Pubkey) -> &mut Self { + self.ncn = Some(ncn); + self + } + #[inline(always)] + pub fn ballot_box(&mut self, ballot_box: solana_program::pubkey::Pubkey) -> &mut Self { + self.ballot_box = Some(ballot_box); + self + } + #[inline(always)] + pub fn vote_account(&mut self, vote_account: solana_program::pubkey::Pubkey) -> &mut Self { + self.vote_account = Some(vote_account); + self + } + #[inline(always)] + pub fn tip_distribution_account( + &mut self, + tip_distribution_account: solana_program::pubkey::Pubkey, + ) -> &mut Self { + self.tip_distribution_account = Some(tip_distribution_account); + self + } + #[inline(always)] + pub fn tip_distribution_config( + &mut self, + tip_distribution_config: solana_program::pubkey::Pubkey, + ) -> &mut Self { + self.tip_distribution_config = Some(tip_distribution_config); + self + } + #[inline(always)] + pub fn priority_fee_distribution_program( + &mut self, + priority_fee_distribution_program: solana_program::pubkey::Pubkey, + ) -> &mut Self { + self.priority_fee_distribution_program = Some(priority_fee_distribution_program); + self + } + #[inline(always)] + pub fn proof(&mut self, proof: Vec<[u8; 32]>) -> &mut Self { + self.proof = Some(proof); + self + } + #[inline(always)] + pub fn merkle_root(&mut self, merkle_root: [u8; 32]) -> &mut Self { + self.merkle_root = Some(merkle_root); + self + } + #[inline(always)] + pub fn max_total_claim(&mut self, max_total_claim: u64) -> &mut Self { + self.max_total_claim = Some(max_total_claim); + self + } + #[inline(always)] + pub fn max_num_nodes(&mut self, max_num_nodes: u64) -> &mut Self { + self.max_num_nodes = Some(max_num_nodes); + self + } + #[inline(always)] + pub fn epoch(&mut self, epoch: u64) -> &mut Self { + self.epoch = Some(epoch); + self + } + /// Add an additional account to the instruction. + #[inline(always)] + pub fn add_remaining_account( + &mut self, + account: solana_program::instruction::AccountMeta, + ) -> &mut Self { + self.__remaining_accounts.push(account); + self + } + /// Add additional accounts to the instruction. + #[inline(always)] + pub fn add_remaining_accounts( + &mut self, + accounts: &[solana_program::instruction::AccountMeta], + ) -> &mut Self { + self.__remaining_accounts.extend_from_slice(accounts); + self + } + #[allow(clippy::clone_on_copy)] + pub fn instruction(&self) -> solana_program::instruction::Instruction { + let accounts = SetPriorityFeeMerkleRoot { + epoch_state: self.epoch_state.expect("epoch_state is not set"), + config: self.config.expect("config is not set"), + ncn: self.ncn.expect("ncn is not set"), + ballot_box: self.ballot_box.expect("ballot_box is not set"), + vote_account: self.vote_account.expect("vote_account is not set"), + tip_distribution_account: self + .tip_distribution_account + .expect("tip_distribution_account is not set"), + tip_distribution_config: self + .tip_distribution_config + .expect("tip_distribution_config is not set"), + priority_fee_distribution_program: self + .priority_fee_distribution_program + .expect("priority_fee_distribution_program is not set"), + }; + let args = SetPriorityFeeMerkleRootInstructionArgs { + proof: self.proof.clone().expect("proof is not set"), + merkle_root: self.merkle_root.clone().expect("merkle_root is not set"), + max_total_claim: self + .max_total_claim + .clone() + .expect("max_total_claim is not set"), + max_num_nodes: self + .max_num_nodes + .clone() + .expect("max_num_nodes is not set"), + epoch: self.epoch.clone().expect("epoch is not set"), + }; + + accounts.instruction_with_remaining_accounts(args, &self.__remaining_accounts) + } +} + +/// `set_priority_fee_merkle_root` CPI accounts. +pub struct SetPriorityFeeMerkleRootCpiAccounts<'a, 'b> { + pub epoch_state: &'b solana_program::account_info::AccountInfo<'a>, + + pub config: &'b solana_program::account_info::AccountInfo<'a>, + + pub ncn: &'b solana_program::account_info::AccountInfo<'a>, + + pub ballot_box: &'b solana_program::account_info::AccountInfo<'a>, + + pub vote_account: &'b solana_program::account_info::AccountInfo<'a>, + + pub tip_distribution_account: &'b solana_program::account_info::AccountInfo<'a>, + + pub tip_distribution_config: &'b solana_program::account_info::AccountInfo<'a>, + + pub priority_fee_distribution_program: &'b solana_program::account_info::AccountInfo<'a>, +} + +/// `set_priority_fee_merkle_root` CPI instruction. +pub struct SetPriorityFeeMerkleRootCpi<'a, 'b> { + /// The program to invoke. + pub __program: &'b solana_program::account_info::AccountInfo<'a>, + + pub epoch_state: &'b solana_program::account_info::AccountInfo<'a>, + + pub config: &'b solana_program::account_info::AccountInfo<'a>, + + pub ncn: &'b solana_program::account_info::AccountInfo<'a>, + + pub ballot_box: &'b solana_program::account_info::AccountInfo<'a>, + + pub vote_account: &'b solana_program::account_info::AccountInfo<'a>, + + pub tip_distribution_account: &'b solana_program::account_info::AccountInfo<'a>, + + pub tip_distribution_config: &'b solana_program::account_info::AccountInfo<'a>, + + pub priority_fee_distribution_program: &'b solana_program::account_info::AccountInfo<'a>, + /// The arguments for the instruction. + pub __args: SetPriorityFeeMerkleRootInstructionArgs, +} + +impl<'a, 'b> SetPriorityFeeMerkleRootCpi<'a, 'b> { + pub fn new( + program: &'b solana_program::account_info::AccountInfo<'a>, + accounts: SetPriorityFeeMerkleRootCpiAccounts<'a, 'b>, + args: SetPriorityFeeMerkleRootInstructionArgs, + ) -> Self { + Self { + __program: program, + epoch_state: accounts.epoch_state, + config: accounts.config, + ncn: accounts.ncn, + ballot_box: accounts.ballot_box, + vote_account: accounts.vote_account, + tip_distribution_account: accounts.tip_distribution_account, + tip_distribution_config: accounts.tip_distribution_config, + priority_fee_distribution_program: accounts.priority_fee_distribution_program, + __args: args, + } + } + #[inline(always)] + pub fn invoke(&self) -> solana_program::entrypoint::ProgramResult { + self.invoke_signed_with_remaining_accounts(&[], &[]) + } + #[inline(always)] + pub fn invoke_with_remaining_accounts( + &self, + remaining_accounts: &[( + &'b solana_program::account_info::AccountInfo<'a>, + bool, + bool, + )], + ) -> solana_program::entrypoint::ProgramResult { + self.invoke_signed_with_remaining_accounts(&[], remaining_accounts) + } + #[inline(always)] + pub fn invoke_signed( + &self, + signers_seeds: &[&[&[u8]]], + ) -> solana_program::entrypoint::ProgramResult { + self.invoke_signed_with_remaining_accounts(signers_seeds, &[]) + } + #[allow(clippy::clone_on_copy)] + #[allow(clippy::vec_init_then_push)] + pub fn invoke_signed_with_remaining_accounts( + &self, + signers_seeds: &[&[&[u8]]], + remaining_accounts: &[( + &'b solana_program::account_info::AccountInfo<'a>, + bool, + bool, + )], + ) -> solana_program::entrypoint::ProgramResult { + let mut accounts = Vec::with_capacity(8 + remaining_accounts.len()); + accounts.push(solana_program::instruction::AccountMeta::new( + *self.epoch_state.key, + false, + )); + accounts.push(solana_program::instruction::AccountMeta::new( + *self.config.key, + false, + )); + accounts.push(solana_program::instruction::AccountMeta::new_readonly( + *self.ncn.key, + false, + )); + accounts.push(solana_program::instruction::AccountMeta::new_readonly( + *self.ballot_box.key, + false, + )); + accounts.push(solana_program::instruction::AccountMeta::new_readonly( + *self.vote_account.key, + false, + )); + accounts.push(solana_program::instruction::AccountMeta::new( + *self.tip_distribution_account.key, + false, + )); + accounts.push(solana_program::instruction::AccountMeta::new_readonly( + *self.tip_distribution_config.key, + false, + )); + accounts.push(solana_program::instruction::AccountMeta::new_readonly( + *self.priority_fee_distribution_program.key, + false, + )); + remaining_accounts.iter().for_each(|remaining_account| { + accounts.push(solana_program::instruction::AccountMeta { + pubkey: *remaining_account.0.key, + is_signer: remaining_account.1, + is_writable: remaining_account.2, + }) + }); + let mut data = SetPriorityFeeMerkleRootInstructionData::new() + .try_to_vec() + .unwrap(); + let mut args = self.__args.try_to_vec().unwrap(); + data.append(&mut args); + + let instruction = solana_program::instruction::Instruction { + program_id: crate::JITO_TIP_ROUTER_ID, + accounts, + data, + }; + let mut account_infos = Vec::with_capacity(8 + 1 + remaining_accounts.len()); + account_infos.push(self.__program.clone()); + account_infos.push(self.epoch_state.clone()); + account_infos.push(self.config.clone()); + account_infos.push(self.ncn.clone()); + account_infos.push(self.ballot_box.clone()); + account_infos.push(self.vote_account.clone()); + account_infos.push(self.tip_distribution_account.clone()); + account_infos.push(self.tip_distribution_config.clone()); + account_infos.push(self.priority_fee_distribution_program.clone()); + remaining_accounts + .iter() + .for_each(|remaining_account| account_infos.push(remaining_account.0.clone())); + + if signers_seeds.is_empty() { + solana_program::program::invoke(&instruction, &account_infos) + } else { + solana_program::program::invoke_signed(&instruction, &account_infos, signers_seeds) + } + } +} + +/// Instruction builder for `SetPriorityFeeMerkleRoot` via CPI. +/// +/// ### Accounts: +/// +/// 0. `[writable]` epoch_state +/// 1. `[writable]` config +/// 2. `[]` ncn +/// 3. `[]` ballot_box +/// 4. `[]` vote_account +/// 5. `[writable]` tip_distribution_account +/// 6. `[]` tip_distribution_config +/// 7. `[]` priority_fee_distribution_program +#[derive(Clone, Debug)] +pub struct SetPriorityFeeMerkleRootCpiBuilder<'a, 'b> { + instruction: Box>, +} + +impl<'a, 'b> SetPriorityFeeMerkleRootCpiBuilder<'a, 'b> { + pub fn new(program: &'b solana_program::account_info::AccountInfo<'a>) -> Self { + let instruction = Box::new(SetPriorityFeeMerkleRootCpiBuilderInstruction { + __program: program, + epoch_state: None, + config: None, + ncn: None, + ballot_box: None, + vote_account: None, + tip_distribution_account: None, + tip_distribution_config: None, + priority_fee_distribution_program: None, + proof: None, + merkle_root: None, + max_total_claim: None, + max_num_nodes: None, + epoch: None, + __remaining_accounts: Vec::new(), + }); + Self { instruction } + } + #[inline(always)] + pub fn epoch_state( + &mut self, + epoch_state: &'b solana_program::account_info::AccountInfo<'a>, + ) -> &mut Self { + self.instruction.epoch_state = Some(epoch_state); + self + } + #[inline(always)] + pub fn config( + &mut self, + config: &'b solana_program::account_info::AccountInfo<'a>, + ) -> &mut Self { + self.instruction.config = Some(config); + self + } + #[inline(always)] + pub fn ncn(&mut self, ncn: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self { + self.instruction.ncn = Some(ncn); + self + } + #[inline(always)] + pub fn ballot_box( + &mut self, + ballot_box: &'b solana_program::account_info::AccountInfo<'a>, + ) -> &mut Self { + self.instruction.ballot_box = Some(ballot_box); + self + } + #[inline(always)] + pub fn vote_account( + &mut self, + vote_account: &'b solana_program::account_info::AccountInfo<'a>, + ) -> &mut Self { + self.instruction.vote_account = Some(vote_account); + self + } + #[inline(always)] + pub fn tip_distribution_account( + &mut self, + tip_distribution_account: &'b solana_program::account_info::AccountInfo<'a>, + ) -> &mut Self { + self.instruction.tip_distribution_account = Some(tip_distribution_account); + self + } + #[inline(always)] + pub fn tip_distribution_config( + &mut self, + tip_distribution_config: &'b solana_program::account_info::AccountInfo<'a>, + ) -> &mut Self { + self.instruction.tip_distribution_config = Some(tip_distribution_config); + self + } + #[inline(always)] + pub fn priority_fee_distribution_program( + &mut self, + priority_fee_distribution_program: &'b solana_program::account_info::AccountInfo<'a>, + ) -> &mut Self { + self.instruction.priority_fee_distribution_program = + Some(priority_fee_distribution_program); + self + } + #[inline(always)] + pub fn proof(&mut self, proof: Vec<[u8; 32]>) -> &mut Self { + self.instruction.proof = Some(proof); + self + } + #[inline(always)] + pub fn merkle_root(&mut self, merkle_root: [u8; 32]) -> &mut Self { + self.instruction.merkle_root = Some(merkle_root); + self + } + #[inline(always)] + pub fn max_total_claim(&mut self, max_total_claim: u64) -> &mut Self { + self.instruction.max_total_claim = Some(max_total_claim); + self + } + #[inline(always)] + pub fn max_num_nodes(&mut self, max_num_nodes: u64) -> &mut Self { + self.instruction.max_num_nodes = Some(max_num_nodes); + self + } + #[inline(always)] + pub fn epoch(&mut self, epoch: u64) -> &mut Self { + self.instruction.epoch = Some(epoch); + self + } + /// Add an additional account to the instruction. + #[inline(always)] + pub fn add_remaining_account( + &mut self, + account: &'b solana_program::account_info::AccountInfo<'a>, + is_writable: bool, + is_signer: bool, + ) -> &mut Self { + self.instruction + .__remaining_accounts + .push((account, is_writable, is_signer)); + self + } + /// Add additional accounts to the instruction. + /// + /// Each account is represented by a tuple of the `AccountInfo`, a `bool` indicating whether the account is writable or not, + /// and a `bool` indicating whether the account is a signer or not. + #[inline(always)] + pub fn add_remaining_accounts( + &mut self, + accounts: &[( + &'b solana_program::account_info::AccountInfo<'a>, + bool, + bool, + )], + ) -> &mut Self { + self.instruction + .__remaining_accounts + .extend_from_slice(accounts); + self + } + #[inline(always)] + pub fn invoke(&self) -> solana_program::entrypoint::ProgramResult { + self.invoke_signed(&[]) + } + #[allow(clippy::clone_on_copy)] + #[allow(clippy::vec_init_then_push)] + pub fn invoke_signed( + &self, + signers_seeds: &[&[&[u8]]], + ) -> solana_program::entrypoint::ProgramResult { + let args = SetPriorityFeeMerkleRootInstructionArgs { + proof: self.instruction.proof.clone().expect("proof is not set"), + merkle_root: self + .instruction + .merkle_root + .clone() + .expect("merkle_root is not set"), + max_total_claim: self + .instruction + .max_total_claim + .clone() + .expect("max_total_claim is not set"), + max_num_nodes: self + .instruction + .max_num_nodes + .clone() + .expect("max_num_nodes is not set"), + epoch: self.instruction.epoch.clone().expect("epoch is not set"), + }; + let instruction = SetPriorityFeeMerkleRootCpi { + __program: self.instruction.__program, + + epoch_state: self + .instruction + .epoch_state + .expect("epoch_state is not set"), + + config: self.instruction.config.expect("config is not set"), + + ncn: self.instruction.ncn.expect("ncn is not set"), + + ballot_box: self.instruction.ballot_box.expect("ballot_box is not set"), + + vote_account: self + .instruction + .vote_account + .expect("vote_account is not set"), + + tip_distribution_account: self + .instruction + .tip_distribution_account + .expect("tip_distribution_account is not set"), + + tip_distribution_config: self + .instruction + .tip_distribution_config + .expect("tip_distribution_config is not set"), + + priority_fee_distribution_program: self + .instruction + .priority_fee_distribution_program + .expect("priority_fee_distribution_program is not set"), + __args: args, + }; + instruction.invoke_signed_with_remaining_accounts( + signers_seeds, + &self.instruction.__remaining_accounts, + ) + } +} + +#[derive(Clone, Debug)] +struct SetPriorityFeeMerkleRootCpiBuilderInstruction<'a, 'b> { + __program: &'b solana_program::account_info::AccountInfo<'a>, + epoch_state: Option<&'b solana_program::account_info::AccountInfo<'a>>, + config: Option<&'b solana_program::account_info::AccountInfo<'a>>, + ncn: Option<&'b solana_program::account_info::AccountInfo<'a>>, + ballot_box: Option<&'b solana_program::account_info::AccountInfo<'a>>, + vote_account: Option<&'b solana_program::account_info::AccountInfo<'a>>, + tip_distribution_account: Option<&'b solana_program::account_info::AccountInfo<'a>>, + tip_distribution_config: Option<&'b solana_program::account_info::AccountInfo<'a>>, + priority_fee_distribution_program: Option<&'b solana_program::account_info::AccountInfo<'a>>, + proof: Option>, + merkle_root: Option<[u8; 32]>, + max_total_claim: Option, + max_num_nodes: Option, + epoch: Option, + /// Additional instruction accounts `(AccountInfo, is_writable, is_signer)`. + __remaining_accounts: Vec<( + &'b solana_program::account_info::AccountInfo<'a>, + bool, + bool, + )>, +} diff --git a/core/src/instruction.rs b/core/src/instruction.rs index b2bfab8d..52e29eb5 100644 --- a/core/src/instruction.rs +++ b/core/src/instruction.rs @@ -228,6 +228,23 @@ pub enum TipRouterInstruction { epoch: u64, }, + /// Set the merkle root after consensus is reached + #[account(0, writable, name = "epoch_state")] + #[account(1, writable, name = "config")] + #[account(2, name = "ncn")] + #[account(3, name = "ballot_box")] + #[account(4, name = "vote_account")] + #[account(5, writable, name = "tip_distribution_account")] + #[account(6, name = "tip_distribution_config")] + #[account(7, name = "priority_fee_distribution_program")] + SetPriorityFeeMerkleRoot { + proof: Vec<[u8; 32]>, + merkle_root: [u8; 32], + max_total_claim: u64, + max_num_nodes: u64, + epoch: u64, + }, + // ---------------------------------------------------- // // ROUTE AND DISTRIBUTE // // ---------------------------------------------------- // diff --git a/idl/jito_tip_router.json b/idl/jito_tip_router.json index e8727b9c..d9b97eed 100644 --- a/idl/jito_tip_router.json +++ b/idl/jito_tip_router.json @@ -903,6 +903,89 @@ "value": 16 } }, + { + "name": "SetPriorityFeeMerkleRoot", + "accounts": [ + { + "name": "epochState", + "isMut": true, + "isSigner": false + }, + { + "name": "config", + "isMut": true, + "isSigner": false + }, + { + "name": "ncn", + "isMut": false, + "isSigner": false + }, + { + "name": "ballotBox", + "isMut": false, + "isSigner": false + }, + { + "name": "voteAccount", + "isMut": false, + "isSigner": false + }, + { + "name": "tipDistributionAccount", + "isMut": true, + "isSigner": false + }, + { + "name": "tipDistributionConfig", + "isMut": false, + "isSigner": false + }, + { + "name": "priorityFeeDistributionProgram", + "isMut": false, + "isSigner": false + } + ], + "args": [ + { + "name": "proof", + "type": { + "vec": { + "array": [ + "u8", + 32 + ] + } + } + }, + { + "name": "merkleRoot", + "type": { + "array": [ + "u8", + 32 + ] + } + }, + { + "name": "maxTotalClaim", + "type": "u64" + }, + { + "name": "maxNumNodes", + "type": "u64" + }, + { + "name": "epoch", + "type": "u64" + } + ], + "discriminant": { + "type": "u8", + "value": 17 + } + }, { "name": "InitializeBaseRewardRouter", "accounts": [ @@ -950,7 +1033,7 @@ ], "discriminant": { "type": "u8", - "value": 17 + "value": 18 } }, { @@ -995,7 +1078,7 @@ ], "discriminant": { "type": "u8", - "value": 18 + "value": 19 } }, { @@ -1059,7 +1142,7 @@ ], "discriminant": { "type": "u8", - "value": 19 + "value": 20 } }, { @@ -1113,7 +1196,7 @@ ], "discriminant": { "type": "u8", - "value": 20 + "value": 21 } }, { @@ -1166,7 +1249,7 @@ ], "discriminant": { "type": "u8", - "value": 21 + "value": 22 } }, { @@ -1265,7 +1348,7 @@ ], "discriminant": { "type": "u8", - "value": 22 + "value": 23 } }, { @@ -1329,7 +1412,7 @@ ], "discriminant": { "type": "u8", - "value": 23 + "value": 24 } }, { @@ -1433,7 +1516,7 @@ ], "discriminant": { "type": "u8", - "value": 24 + "value": 25 } }, { @@ -1542,7 +1625,7 @@ ], "discriminant": { "type": "u8", - "value": 25 + "value": 26 } }, { @@ -1617,7 +1700,7 @@ ], "discriminant": { "type": "u8", - "value": 26 + "value": 27 } }, { @@ -1678,7 +1761,7 @@ ], "discriminant": { "type": "u8", - "value": 27 + "value": 28 } }, { @@ -1728,7 +1811,7 @@ ], "discriminant": { "type": "u8", - "value": 28 + "value": 29 } }, { @@ -1790,7 +1873,7 @@ ], "discriminant": { "type": "u8", - "value": 29 + "value": 30 } }, { @@ -1827,7 +1910,7 @@ ], "discriminant": { "type": "u8", - "value": 30 + "value": 31 } }, { @@ -1876,7 +1959,7 @@ ], "discriminant": { "type": "u8", - "value": 31 + "value": 32 } }, { @@ -1919,7 +2002,7 @@ ], "discriminant": { "type": "u8", - "value": 32 + "value": 33 } }, { @@ -1975,7 +2058,7 @@ ], "discriminant": { "type": "u8", - "value": 33 + "value": 34 } }, { @@ -2034,7 +2117,7 @@ ], "discriminant": { "type": "u8", - "value": 34 + "value": 35 } } ], diff --git a/integration_tests/tests/fixtures/jito_priority_fee_distribution.so b/integration_tests/tests/fixtures/jito_priority_fee_distribution.so new file mode 100755 index 0000000000000000000000000000000000000000..36235ee627d3532401fb3b4d8e27b0733087a51f GIT binary patch literal 369072 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μ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 P-qxuRwFl`jF8}`mW(}T= literal 0 HcmV?d00001 diff --git a/integration_tests/tests/fixtures/test_builder.rs b/integration_tests/tests/fixtures/test_builder.rs index 24ebf6ca..dc4dbca5 100644 --- a/integration_tests/tests/fixtures/test_builder.rs +++ b/integration_tests/tests/fixtures/test_builder.rs @@ -3,6 +3,7 @@ use std::{ fmt::{Debug, Formatter}, }; +use jito_priority_fee_distribution_sdk::jito_priority_fee_distribution; use jito_restaking_core::{config::Config, ncn_vault_ticket::NcnVaultTicket}; use jito_tip_distribution_sdk::jito_tip_distribution; use jito_tip_router_core::{ @@ -113,6 +114,11 @@ impl TestBuilder { // Tests that invoke this program should be in the "bpf" module so we can run them separately with the bpf vm. // Anchor programs do not expose a compatible entrypoint for solana_program_test::processor! program_test.add_program("jito_tip_distribution", jito_tip_distribution::ID, None); + program_test.add_program( + "jito_priority_fee_distribution", + jito_priority_fee_distribution::ID, + None, + ); program_test } else { diff --git a/integration_tests/tests/fixtures/tip_router_client.rs b/integration_tests/tests/fixtures/tip_router_client.rs index 1d493e04..e0408114 100644 --- a/integration_tests/tests/fixtures/tip_router_client.rs +++ b/integration_tests/tests/fixtures/tip_router_client.rs @@ -1,4 +1,5 @@ use jito_bytemuck::AccountDeserialize; +use jito_priority_fee_distribution_sdk::jito_priority_fee_distribution; use jito_restaking_core::{ config::Config, ncn_operator_state::NcnOperatorState, ncn_vault_ticket::NcnVaultTicket, }; @@ -17,7 +18,8 @@ use jito_tip_router_client::{ ReallocBaseRewardRouterBuilder, ReallocEpochStateBuilder, ReallocOperatorSnapshotBuilder, ReallocVaultRegistryBuilder, ReallocWeightTableBuilder, RegisterVaultBuilder, RouteBaseRewardsBuilder, RouteNcnRewardsBuilder, SetMerkleRootBuilder, - SnapshotVaultOperatorDelegationBuilder, SwitchboardSetWeightBuilder, + SetPriorityFeeMerkleRootBuilder, SnapshotVaultOperatorDelegationBuilder, + SwitchboardSetWeightBuilder, }, types::ConfigAdminRole, }; @@ -1461,6 +1463,94 @@ impl TipRouterClient { .await } + pub async fn do_set_priority_fee_merkle_root( + &mut self, + ncn: Pubkey, + vote_account: Pubkey, + proof: Vec<[u8; 32]>, + merkle_root: [u8; 32], + max_total_claim: u64, + max_num_nodes: u64, + epoch: u64, + ) -> Result<(), TestError> { + let config = NcnConfig::find_program_address(&jito_tip_router_program::id(), &ncn).0; + let ballot_box = + BallotBox::find_program_address(&jito_tip_router_program::id(), &ncn, epoch).0; + + let priority_fee_distribution_program = jito_priority_fee_distribution::ID; + let tip_distribution_account = derive_tip_distribution_account_address( + &priority_fee_distribution_program, + &vote_account, + epoch - 1, + ) + .0; + + let tip_distribution_config = jito_tip_distribution_sdk::derive_config_account_address( + &priority_fee_distribution_program, + ) + .0; + + self.set_priority_fee_merkle_root( + config, + ncn, + ballot_box, + vote_account, + tip_distribution_account, + tip_distribution_config, + priority_fee_distribution_program, + proof, + merkle_root, + max_total_claim, + max_num_nodes, + epoch, + ) + .await + } + + pub async fn set_priority_fee_merkle_root( + &mut self, + config: Pubkey, + ncn: Pubkey, + ballot_box: Pubkey, + vote_account: Pubkey, + tip_distribution_account: Pubkey, + tip_distribution_config: Pubkey, + priority_fee_distribution_program: Pubkey, + proof: Vec<[u8; 32]>, + merkle_root: [u8; 32], + max_total_claim: u64, + max_num_nodes: u64, + epoch: u64, + ) -> Result<(), TestError> { + let epoch_state = + EpochState::find_program_address(&jito_tip_router_program::id(), &ncn, epoch).0; + + let ix = SetPriorityFeeMerkleRootBuilder::new() + .epoch_state(epoch_state) + .config(config) + .ncn(ncn) + .ballot_box(ballot_box) + .vote_account(vote_account) + .tip_distribution_account(tip_distribution_account) + .tip_distribution_config(tip_distribution_config) + .priority_fee_distribution_program(priority_fee_distribution_program) + .proof(proof) + .merkle_root(merkle_root) + .max_total_claim(max_total_claim) + .max_num_nodes(max_num_nodes) + .epoch(epoch) + .instruction(); + + let blockhash = self.banks_client.get_latest_blockhash().await?; + self.process_transaction(&Transaction::new_signed_with_payer( + &[ix], + Some(&self.payer.pubkey()), + &[&self.payer], + blockhash, + )) + .await + } + pub async fn do_admin_set_tie_breaker( &mut self, ncn: Pubkey, diff --git a/integration_tests/tests/tip_router/bpf/set_priority_fee_merkle_root.rs b/integration_tests/tests/tip_router/bpf/set_priority_fee_merkle_root.rs index 5dc56db4..5bb41930 100644 --- a/integration_tests/tests/tip_router/bpf/set_priority_fee_merkle_root.rs +++ b/integration_tests/tests/tip_router/bpf/set_priority_fee_merkle_root.rs @@ -285,7 +285,7 @@ mod set_merkle_root { // Test wrong proof let res = tip_router_client - .do_set_merkle_root( + .do_set_priority_fee_merkle_root( ncn_address, vote_account, vec![[1; 32]], @@ -299,7 +299,7 @@ mod set_merkle_root { // Invoke set_merkle_root tip_router_client - .do_set_merkle_root( + .do_set_priority_fee_merkle_root( ncn_address, vote_account, proof, @@ -446,7 +446,7 @@ mod set_merkle_root { // Invoke set_merkle_root tip_router_client - .do_set_merkle_root( + .do_set_priority_fee_merkle_root( ncn, vote_account, proof, @@ -526,7 +526,7 @@ mod set_merkle_root { // Try setting merkle root before consensus let res = tip_router_client - .do_set_merkle_root( + .do_set_priority_fee_merkle_root( ncn, vote_account, proof, diff --git a/program/Cargo.toml b/program/Cargo.toml index abc285d4..ff1126b7 100644 --- a/program/Cargo.toml +++ b/program/Cargo.toml @@ -31,6 +31,7 @@ cfg-if = { workspace = true } const_str_to_pubkey = { workspace = true } jito-bytemuck = { workspace = true } jito-jsm-core = { workspace = true } +jito-priority-fee-distribution-sdk = { workspace = true } jito-restaking-core = { workspace = true } jito-restaking-program = { workspace = true } jito-restaking-sdk = { workspace = true } diff --git a/program/src/lib.rs b/program/src/lib.rs index 1c2c44cc..3401d7dd 100644 --- a/program/src/lib.rs +++ b/program/src/lib.rs @@ -31,6 +31,7 @@ mod register_vault; mod route_base_rewards; mod route_ncn_rewards; mod set_merkle_root; +mod set_priority_fee_merkle_root; mod snapshot_vault_operator_delegation; mod switchboard_set_weight; @@ -73,6 +74,7 @@ use crate::{ realloc_weight_table::process_realloc_weight_table, register_vault::process_register_vault, route_base_rewards::process_route_base_rewards, route_ncn_rewards::process_route_ncn_rewards, set_merkle_root::process_set_merkle_root, + set_priority_fee_merkle_root::process_set_priority_fee_merkle_root, snapshot_vault_operator_delegation::process_snapshot_vault_operator_delegation, switchboard_set_weight::process_switchboard_set_weight, }; @@ -218,6 +220,24 @@ pub fn process_instruction( epoch, ) } + TipRouterInstruction::SetPriorityFeeMerkleRoot { + proof, + merkle_root, + max_total_claim, + max_num_nodes, + epoch, + } => { + msg!("Instruction: SetPriorityFeeMerkleRoot"); + process_set_priority_fee_merkle_root( + program_id, + accounts, + proof, + merkle_root, + max_total_claim, + max_num_nodes, + epoch, + ) + } // ---------------------------------------------------- // // ROUTE AND DISTRIBUTE // diff --git a/program/src/set_priority_fee_merkle_root.rs b/program/src/set_priority_fee_merkle_root.rs new file mode 100644 index 00000000..80e616ee --- /dev/null +++ b/program/src/set_priority_fee_merkle_root.rs @@ -0,0 +1,106 @@ +use jito_bytemuck::AccountDeserialize; +use jito_priority_fee_distribution_sdk::{ + derive_tip_distribution_account_address, instruction::upload_merkle_root_ix, + jito_priority_fee_distribution, +}; +use jito_restaking_core::ncn::Ncn; +use jito_tip_router_core::{ + ballot_box::BallotBox, config::Config as NcnConfig, epoch_state::EpochState, + error::TipRouterError, +}; +use solana_program::{ + account_info::AccountInfo, entrypoint::ProgramResult, msg, program::invoke_signed, + program_error::ProgramError, pubkey::Pubkey, +}; + +pub fn process_set_priority_fee_merkle_root( + program_id: &Pubkey, + accounts: &[AccountInfo], + proof: Vec<[u8; 32]>, + merkle_root: [u8; 32], + max_total_claim: u64, + max_num_nodes: u64, + epoch: u64, +) -> ProgramResult { + let [epoch_state, ncn_config, ncn, ballot_box, vote_account, tip_distribution_account, tip_distribution_config, tip_distribution_program] = + accounts + else { + return Err(ProgramError::NotEnoughAccountKeys); + }; + + EpochState::load(program_id, epoch_state, ncn.key, epoch, true)?; + NcnConfig::load(program_id, ncn_config, ncn.key, true)?; + Ncn::load(&jito_restaking_program::id(), ncn, false)?; + BallotBox::load(program_id, ballot_box, ncn.key, epoch, false)?; + + if tip_distribution_program + .key + .ne(&jito_priority_fee_distribution::ID) + { + msg!("Incorrect tip distribution program"); + return Err(ProgramError::InvalidAccountData); + } + + let tip_distribution_epoch = epoch + .checked_sub(1) + .ok_or(TipRouterError::ArithmeticUnderflowError)?; + let (tip_distribution_address, _) = derive_tip_distribution_account_address( + tip_distribution_program.key, + vote_account.key, + tip_distribution_epoch, + ); + + if tip_distribution_address.ne(tip_distribution_account.key) { + msg!("Incorrect tip distribution account"); + return Err(ProgramError::InvalidAccountData); + } + + let ballot_box_data = ballot_box.data.borrow(); + let ballot_box = BallotBox::try_from_slice_unchecked(&ballot_box_data)?; + + if !ballot_box.is_consensus_reached() { + msg!("Ballot box not finalized"); + return Err(TipRouterError::ConsensusNotReached.into()); + } + + ballot_box.verify_merkle_root( + &tip_distribution_address, + proof, + &merkle_root, + max_total_claim, + max_num_nodes, + )?; + + let (_, bump, mut ncn_config_seeds) = NcnConfig::find_program_address(program_id, ncn.key); + ncn_config_seeds.push(vec![bump]); + + invoke_signed( + &upload_merkle_root_ix( + *tip_distribution_config.key, + *ncn_config.key, + *tip_distribution_account.key, + merkle_root, + max_total_claim, + max_num_nodes, + ), + &[ + tip_distribution_config.clone(), + tip_distribution_account.clone(), + ncn_config.clone(), + ], + &[ncn_config_seeds + .iter() + .map(|s| s.as_slice()) + .collect::>() + .as_slice()], + )?; + + // Update Epoch State + { + let mut epoch_state_data = epoch_state.try_borrow_mut_data()?; + let epoch_state_account = EpochState::try_from_slice_unchecked_mut(&mut epoch_state_data)?; + epoch_state_account.update_set_merkle_root()?; + } + + Ok(()) +}