rename protocol -> router and reorg (#130)

* rename protocol -> router and reorg

* reconfigure tilt

* added tests for insufficient rent

* address comments

Author: anihamde

Tiltfile

@@ -158,13 +158,13 @@ local_resource(
 # need to run initialize instructions for the programs one time, script skips if already initialized
 local_resource(
     "svm-initialize-programs",
-    "poetry -C per_sdk run python3 -m per_sdk.svm.initialize_programs -v --file-private-key-payer keypairs/searcher.json --file-private-key-admin keypairs/admin.json --file-private-key-relayer-signer keypairs/relayer_signer.json --express-relay-program GwEtasTAxdS9neVE4GPUpcwR7DB7AizntQSPcG36ubZM --dummy-program HYCgALnu6CM2gkQVopa1HGaNf8Vzbs9bomWRiKP267P3 --rpc-url %s" % rpc_url_solana,
+    "poetry -C per_sdk run python3 -m per_sdk.svm.initialize_programs -v --file-private-key-payer keypairs/searcher.json --file-private-key-admin keypairs/admin.json --file-private-key-relayer-signer keypairs/relayer_signer.json --express-relay-program GwEtasTAxdS9neVE4GPUpcwR7DB7AizntQSPcG36ubZM --rpc-url %s" % rpc_url_solana,
     resource_deps=["svm-setup-accounts"]
 )
 
 # craft dummy tx, submits as a bid to auction server or submits relayer-signed tx directly to solana cluster
 local_resource(
     "svm-submit-bid",
-    "poetry -C per_sdk run python3 -m per_sdk.svm.dummy_tx -v --file-private-key-searcher keypairs/searcher.json --file-private-key-relayer-signer keypairs/relayer_signer.json --bid 100 --auction-server-url http://localhost:9000 --express-relay-program GwEtasTAxdS9neVE4GPUpcwR7DB7AizntQSPcG36ubZM --dummy-program HYCgALnu6CM2gkQVopa1HGaNf8Vzbs9bomWRiKP267P3",
+    "poetry -C per_sdk run python3 -m per_sdk.svm.dummy_tx -v --file-private-key-searcher keypairs/searcher.json --file-private-key-relayer-signer keypairs/relayer_signer.json --bid 100000000 --auction-server-url http://localhost:9000 --express-relay-program GwEtasTAxdS9neVE4GPUpcwR7DB7AizntQSPcG36ubZM --dummy-program HYCgALnu6CM2gkQVopa1HGaNf8Vzbs9bomWRiKP267P3",
     resource_deps=["svm-initialize-programs", "auction-server"],
 )

express_relay/programs/dummy/src/lib.rs

@@ -1,24 +1,20 @@
 use anchor_lang::prelude::*;
 use anchor_lang::solana_program::sysvar::instructions as sysvar_instructions;
-use express_relay::{self, program::ExpressRelay, cpi::accounts::CheckPermission, state::SEED_EXPRESS_RELAY_FEES};
+use express_relay::{self, program::ExpressRelay, cpi::accounts::CheckPermission};
 
 declare_id!("HYCgALnu6CM2gkQVopa1HGaNf8Vzbs9bomWRiKP267P3");
 
 #[program]
 pub mod dummy {
     use super::*;
 
-    pub fn initialize(_ctx: Context<Initialize>) -> Result<()> {
-        Ok(())
-    }
-
     pub fn do_nothing(ctx: Context<DoNothing>) -> Result<()> {
         // just want to check if the permission is valid, and do nothing else
         let cpi_program = ctx.accounts.express_relay.to_account_info();
         let cpi_accounts = CheckPermission {
             sysvar_instructions: ctx.accounts.sysvar_instructions.to_account_info(),
             permission: ctx.accounts.permission.to_account_info(),
-            protocol: ctx.accounts.protocol.to_account_info(),
+            router: ctx.accounts.router.to_account_info(),
         };
         let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
         express_relay::cpi::check_permission(cpi_ctx)?;
@@ -27,18 +23,6 @@ pub mod dummy {
     }
 }
 
-#[derive(Accounts)]
-pub struct Initialize<'info> {
-    #[account(mut)]
-    pub payer: Signer<'info>,
-
-    /// CHECK: don't care what this PDA looks like
-    #[account(init, payer = payer, space = 0, seeds = [SEED_EXPRESS_RELAY_FEES], bump)]
-    pub fee_receiver_express_relay: UncheckedAccount<'info>,
-
-    pub system_program: Program<'info, System>,
-}
-
 #[derive(Accounts)]
 pub struct DoNothing<'info> {
     #[account(mut)]
@@ -53,7 +37,6 @@ pub struct DoNothing<'info> {
     /// CHECK: this is the permission key
     pub permission: UncheckedAccount<'info>,
 
-    /// CHECK: this is the current program
-    #[account(address = crate::ID)]
-    pub protocol: UncheckedAccount<'info>,
+    /// CHECK: this is the address to receive express relay fees at
+    pub router: UncheckedAccount<'info>,
 }

express_relay/programs/express_relay/src/error.rs

@@ -16,10 +16,6 @@ pub enum ErrorCode {
     MultiplePermissions,
     #[msg("Insufficient Searcher Funds")]
     InsufficientSearcherFunds,
-    #[msg("Insufficient protocol fee receiver funds for rent")]
-    InsufficientProtocolFeeReceiverRent,
-    #[msg("Insufficient relayer fee receiver funds for rent")]
-    InsufficientRelayerFeeReceiverRent,
-    #[msg("Invalid PDA provided")]
-    InvalidPDAProvided,
+    #[msg("Insufficient funds for rent")]
+    InsufficientRent,
 }

express_relay/programs/express_relay/src/lib.rs

@@ -18,15 +18,15 @@ pub mod express_relay {
     use super::*;
 
     pub fn initialize(ctx: Context<Initialize>, data: InitializeArgs) -> Result<()> {
-        validate_fee_split(data.split_protocol_default)?;
+        validate_fee_split(data.split_router_default)?;
         validate_fee_split(data.split_relayer)?;
 
         let express_relay_metadata_data = &mut ctx.accounts.express_relay_metadata;
 
         express_relay_metadata_data.admin = *ctx.accounts.admin.key;
         express_relay_metadata_data.relayer_signer = *ctx.accounts.relayer_signer.key;
         express_relay_metadata_data.fee_receiver_relayer = *ctx.accounts.fee_receiver_relayer.key;
-        express_relay_metadata_data.split_protocol_default = data.split_protocol_default;
+        express_relay_metadata_data.split_router_default = data.split_router_default;
         express_relay_metadata_data.split_relayer = data.split_relayer;
 
         Ok(())
@@ -50,27 +50,27 @@ pub mod express_relay {
     }
 
     pub fn set_splits(ctx: Context<SetSplits>, data: SetSplitsArgs) -> Result<()> {
-        validate_fee_split(data.split_protocol_default)?;
+        validate_fee_split(data.split_router_default)?;
         validate_fee_split(data.split_relayer)?;
 
         let express_relay_metadata_data = &mut ctx.accounts.express_relay_metadata;
 
-        express_relay_metadata_data.split_protocol_default = data.split_protocol_default;
+        express_relay_metadata_data.split_router_default = data.split_router_default;
         express_relay_metadata_data.split_relayer = data.split_relayer;
 
         Ok(())
     }
 
-    pub fn set_protocol_split(ctx: Context<SetProtocolSplit>, data: SetProtocolSplitArgs) -> Result<()> {
-        validate_fee_split(data.split_protocol)?;
+    pub fn set_router_split(ctx: Context<SetRouterSplit>, data: SetRouterSplitArgs) -> Result<()> {
+        validate_fee_split(data.split_router)?;
 
-        ctx.accounts.protocol_config.protocol = *ctx.accounts.protocol.key;
-        ctx.accounts.protocol_config.split = data.split_protocol;
+        ctx.accounts.router_config.router = *ctx.accounts.router.key;
+        ctx.accounts.router_config.split = data.split_router;
 
         Ok(())
     }
 
-    // Submits a bid for a particular (protocol, permission) pair and distributes bids according to splits
+    // Submits a bid for a particular (permission, router) pair and distributes bids according to splits
     pub fn submit_bid(ctx: Context<SubmitBid>, data: SubmitBidArgs) -> Result<()> {
         if data.deadline < Clock::get()?.unix_timestamp {
             return err!(ErrorCode::DeadlinePassed);
@@ -84,18 +84,18 @@ pub mod express_relay {
         // check "no reentrancy"--submit_bid instruction only used once in transaction
         // this is done to prevent an exploit where a searcher submits a transaction with multiple submit_bid instructions with different permission keys
         // that would allow the searcher to win the right to perform the transaction if they won just one of the auctions
-        let permission_count = num_permissions_in_tx(ctx.accounts.sysvar_instructions.clone(), None, None)?;
+        let permission_count = num_permissions_in_tx(ctx.accounts.sysvar_instructions.clone(), None)?;
         if permission_count > 1 {
             return err!(ErrorCode::MultiplePermissions);
         }
 
         handle_bid_payment(ctx, data.bid_amount)
     }
 
-    // Checks if permissioning exists for a particular (protocol, permission) pair within the same transaction
-    // Permissioning takes the form of a submit_bid instruction with matching protocol and permission accounts
+    // Checks if permissioning exists for a particular (permission, router) pair within the same transaction
+    // Permissioning takes the form of a submit_bid instruction with matching permission and router accounts
     pub fn check_permission(ctx: Context<CheckPermission>) -> Result<()> {
-        let num_permissions = num_permissions_in_tx(ctx.accounts.sysvar_instructions.clone(), Some(*ctx.accounts.permission.key), Some(*ctx.accounts.protocol.key))?;
+        let num_permissions = num_permissions_in_tx(ctx.accounts.sysvar_instructions.clone(), Some(PermissionInfo {permission: *ctx.accounts.permission.key, router: *ctx.accounts.router.key}))?;
 
         if num_permissions == 0 {
             return err!(ErrorCode::MissingPermission);
@@ -121,7 +121,7 @@ pub mod express_relay {
 
 #[derive(AnchorSerialize, AnchorDeserialize, Eq, PartialEq, Clone, Copy, Debug)]
 pub struct InitializeArgs {
-    pub split_protocol_default: u64,
+    pub split_router_default: u64,
     pub split_relayer: u64
 }
 
@@ -174,7 +174,7 @@ pub struct SetRelayer<'info> {
 
 #[derive(AnchorSerialize, AnchorDeserialize, Eq, PartialEq, Clone, Copy, Debug)]
 pub struct SetSplitsArgs {
-    pub split_protocol_default: u64,
+    pub split_router_default: u64,
     pub split_relayer: u64,
 }
 
@@ -188,23 +188,23 @@ pub struct SetSplits<'info> {
 }
 
 #[derive(AnchorSerialize, AnchorDeserialize, Eq, PartialEq, Clone, Copy, Debug)]
-pub struct SetProtocolSplitArgs {
-    pub split_protocol: u64,
+pub struct SetRouterSplitArgs {
+    pub split_router: u64,
 }
 
 #[derive(Accounts)]
-pub struct SetProtocolSplit<'info> {
+pub struct SetRouterSplit<'info> {
     #[account(mut)]
     pub admin: Signer<'info>,
 
-    #[account(init_if_needed, payer = admin, space = RESERVE_EXPRESS_RELAY_CONFIG_PROTOCOL, seeds = [SEED_CONFIG_PROTOCOL, protocol.key().as_ref()], bump)]
-    pub protocol_config: Account<'info, ConfigProtocol>,
+    #[account(init_if_needed, payer = admin, space = RESERVE_EXPRESS_RELAY_CONFIG_ROUTER, seeds = [SEED_CONFIG_ROUTER, router.key().as_ref()], bump)]
+    pub router_config: Account<'info, ConfigRouter>,
 
     #[account(seeds = [SEED_METADATA], bump, has_one = admin)]
     pub express_relay_metadata: Account<'info, ExpressRelayMetadata>,
 
-    /// CHECK: this is just the protocol fee receiver PK
-    pub protocol: UncheckedAccount<'info>,
+    /// CHECK: this is just the router fee receiver PK
+    pub router: UncheckedAccount<'info>,
 
     pub system_program: Program<'info, System>,
 }
@@ -225,21 +225,18 @@ pub struct SubmitBid<'info> {
     /// CHECK: this is the permission_key
     pub permission: UncheckedAccount<'info>,
 
-    /// CHECK: this is the protocol/router address
-    pub protocol: UncheckedAccount<'info>,
+    /// CHECK: don't care what this looks like
+    #[account(mut)]
+    pub router: UncheckedAccount<'info>,
 
-    /// CHECK: this cannot be checked against ConfigProtocol bc it may not be initialized bc anchor. we need to check this config even when unused to make sure unique fee splits don't exist
-    #[account(seeds = [SEED_CONFIG_PROTOCOL, protocol.key().as_ref()], bump)]
-    pub protocol_config: UncheckedAccount<'info>,
+    /// CHECK: this cannot be checked against ConfigRouter bc it may not be initialized bc anchor. we need to check this config even when unused to make sure unique fee splits don't exist
+    #[account(seeds = [SEED_CONFIG_ROUTER, router.key().as_ref()], bump)]
+    pub router_config: UncheckedAccount<'info>,
 
     /// CHECK: this is just a PK for the relayer to receive fees at
     #[account(mut)]
     pub fee_receiver_relayer: UncheckedAccount<'info>,
 
-    /// CHECK: don't care what this looks like; if PDA, validate within program logic
-    #[account(mut)]
-    pub fee_receiver_protocol: UncheckedAccount<'info>,
-
     #[account(mut, seeds = [SEED_METADATA], bump, has_one = relayer_signer, has_one = fee_receiver_relayer)]
     pub express_relay_metadata: Account<'info, ExpressRelayMetadata>,
 
@@ -259,8 +256,8 @@ pub struct CheckPermission<'info> {
     /// CHECK: this is the permission_key
     pub permission: UncheckedAccount<'info>,
 
-    /// CHECK: this is the protocol/router address
-    pub protocol: UncheckedAccount<'info>,
+    /// CHECK: this is the router address
+    pub router: UncheckedAccount<'info>,
 }
 
 #[derive(Accounts)]

express_relay/programs/express_relay/src/state.rs

@@ -2,8 +2,6 @@ use anchor_lang::prelude::*;
 
 pub const FEE_SPLIT_PRECISION: u64 = 10_000;
 
-pub const SEED_EXPRESS_RELAY_FEES: &[u8] = b"express_relay_fees";
-
 pub const RESERVE_EXPRESS_RELAY_METADATA: usize = 8+112+300;
 pub const SEED_METADATA: &[u8] = b"metadata";
 
@@ -13,18 +11,18 @@ pub struct ExpressRelayMetadata {
     pub admin: Pubkey,
     pub relayer_signer: Pubkey,
     pub fee_receiver_relayer: Pubkey,
-    // the portion of the bid that goes to the protocol, in bps
-    pub split_protocol_default: u64,
-    // the portion of the remaining bid (after protocol fees) that goes to the relayer, in bps
+    // the portion of the bid that goes to the router, in bps
+    pub split_router_default: u64,
+    // the portion of the remaining bid (after router fees) that goes to the relayer, in bps
     pub split_relayer: u64,
 }
 
-pub const RESERVE_EXPRESS_RELAY_CONFIG_PROTOCOL: usize = 8+40+200;
-pub const SEED_CONFIG_PROTOCOL: &[u8] = b"config_protocol";
+pub const RESERVE_EXPRESS_RELAY_CONFIG_ROUTER: usize = 8+40+200;
+pub const SEED_CONFIG_ROUTER: &[u8] = b"config_router";
 
 #[account]
 #[derive(Default)]
-pub struct ConfigProtocol {
-    pub protocol: Pubkey,
+pub struct ConfigRouter {
+    pub router: Pubkey,
     pub split: u64,
 }