revoke whitelist logic

rfq/program/src/constants.rs

@@ -0,0 +1 @@
+pub const MAX_WHITELIST_SIZE: u8 = 20;

rfq/program/src/errors.rs

@@ -114,8 +114,6 @@ pub enum ProtocolError {
     DefaultValueIsNotPermitted,
     #[msg("Specified oracle source is missing")]
     OracleSourceIsMissing,
-    #[msg("Address Already Exists on Whitelist")]
-    AddressAlreadyExistsOnWhitelist,
     #[msg("Whitelist Maximum Capacity Reached")]
     WhitelistMaximumCapacityReached,
     #[msg("Cannot Respond as Maker Address not Whitelisted")]

rfq/program/src/instructions/whitelist/create_whitelist.rs

@@ -1,16 +1,17 @@
-use crate::{errors::ProtocolError, state::whitelist::Whitelist};
+
+use crate::{errors::ProtocolError, state::whitelist::Whitelist,constants::MAX_WHITELIST_SIZE};
 use anchor_lang::prelude::*;
 use std::mem;
 
 #[derive(Accounts)]
 #[instruction(
-    expected_whitelist_size: u16
+    length: u8
 )]
 pub struct CreateWhitelistAccounts<'info> {
     #[account(
         init_if_needed,
         payer = creator,
-        space = 8 + mem::size_of::<Whitelist>() + (expected_whitelist_size as usize)
+        space = get_whitelist_size_from_length(length),
     )]
     pub whitelist_account: Box<Account<'info, Whitelist>>,
     #[account(mut)]
@@ -20,11 +21,10 @@ pub struct CreateWhitelistAccounts<'info> {
 
 pub fn create_whitelist_instruction(
     ctx: Context<CreateWhitelistAccounts>,
-    expected_whitelist_size: u16,
+    length:u8,
     whitelist_to_add: Vec<Pubkey>,
 ) -> Result<()> {
-    let expected_whitelist_capacity = calculate_expected_capacity(expected_whitelist_size);
-    validate_whitelist_inputs(expected_whitelist_capacity, &whitelist_to_add)?;
+    validate_whitelist_inputs(length)?;
     let CreateWhitelistAccounts {
         creator,
         whitelist_account,
@@ -34,25 +34,23 @@ pub fn create_whitelist_instruction(
     whitelist_account.set_inner(Whitelist {
         creator: creator.key(),
         whitelist: whitelist_to_add,
-        capacity: expected_whitelist_capacity,
     });
 
     Ok(())
 }
 
 fn validate_whitelist_inputs(
-    expected_whitelist_capacity: u8,
-    whitelist_to_add: &Vec<Pubkey>,
+    length:u8,
 ) -> Result<()> {
     require!(
-        whitelist_to_add.len() <= (expected_whitelist_capacity as usize),
+        length <= MAX_WHITELIST_SIZE ,
         ProtocolError::WhitelistMaximumCapacityReached
     );
 
     Ok(())
 }
 
-fn calculate_expected_capacity(expected_whitelist_size: u16) -> u8 {
-    let pubkey_size = 32;
-    (expected_whitelist_size / pubkey_size) as u8
-}
+
+fn get_whitelist_size_from_length(length:u8) -> usize {
+    8 + mem::size_of::<Whitelist>() + (length as u64 * 32 as u64) as usize
+}

rfq/program/src/instructions/whitelist/mod.rs

@@ -1,4 +1,2 @@
-pub mod add_address_to_whitelist;
 pub mod cleanup_whitelist;
 pub mod create_whitelist;
-pub mod remove_address_from_whitelist;

rfq/program/src/lib.rs

@@ -13,6 +13,7 @@ pub mod interfaces;
 pub mod seeds;
 pub mod state;
 pub mod utils;
+pub mod constants;
 
 use instructions::collateral::fund_collateral::*;
 use instructions::collateral::initialize_collateral::*;
@@ -45,10 +46,8 @@ use instructions::rfq::settle_one_party_default::*;
 use instructions::rfq::settle_two_party_default::*;
 use instructions::rfq::unlock_response_collateral::*;
 use instructions::rfq::unlock_rfq_collateral::*;
-use instructions::whitelist::add_address_to_whitelist::*;
 use instructions::whitelist::cleanup_whitelist::*;
 use instructions::whitelist::create_whitelist::*;
-use instructions::whitelist::remove_address_from_whitelist::*;
 use state::*;
 
 security_txt! {
@@ -329,27 +328,14 @@ pub mod rfq {
 
     pub fn create_whitelist<'info>(
         ctx: Context<'_, '_, '_, 'info, CreateWhitelistAccounts<'info>>,
-        expected_whitelist_size: u16,
+        length:u8,
         whitelist: Vec<Pubkey>,
     ) -> Result<()> {
-        create_whitelist_instruction(ctx, expected_whitelist_size, whitelist)
+        create_whitelist_instruction(ctx,length,whitelist)
     }
 
     pub fn clean_up_whitelist(ctx: Context<CleanUpWhitelistAccounts>) -> Result<()> {
         clean_up_whitelist_instruction(ctx)
     }
 
-    pub fn add_address_to_whitelist(
-        ctx: Context<AddAddressToWhitelistAccounts>,
-        address: Pubkey,
-    ) -> Result<()> {
-        add_address_to_whitelist_instruction(ctx, address)
-    }
-
-    pub fn remove_address_from_whitelist(
-        ctx: Context<RemoveAddressToWhitelistAccounts>,
-        address: Pubkey,
-    ) -> Result<()> {
-        remove_address_from_whitelist_instruction(ctx, address)
-    }
 }

rfq/program/src/state/whitelist.rs

@@ -3,7 +3,6 @@ use anchor_lang::prelude::*;
 #[account]
 pub struct Whitelist {
     pub creator: Pubkey,
-    pub capacity: u8,
     pub whitelist: Vec<Pubkey>,
 }
 

tests/integration/spot.spec.ts

@@ -459,12 +459,10 @@ describe("RFQ Spot instrument integration tests", () => {
 
   it("Create two-way RFQ with one spot leg add a whitelist of 3 addresses , respond  ", async () => {
     const whitelistKeypair = Keypair.generate();
-    let whitelist = await context.createWhitelist(
-      whitelistKeypair,
-      context.taker.publicKey,
-      [context.maker.publicKey, context.dao.publicKey],
-      10
-    );
+    let whitelist = await context.createWhitelist(whitelistKeypair, context.taker.publicKey, [
+      context.maker.publicKey,
+      context.dao.publicKey,
+    ]);
 
     // create a two way RFQ specifying 1 bitcoin as a leg
     const rfq = await context.createRfq({
@@ -485,12 +483,10 @@ describe("RFQ Spot instrument integration tests", () => {
   it("Create two-way RFQ with one spot leg add a whitelist of 3 addresses , respond but maker not in list ", async () => {
     const whitelistKeypair = Keypair.generate();
     const newPubkey = new PublicKey("2Jpwh3rvtHe2X67TxpAGEB4x751FNMwWzDyQHhBjqfKg");
-    let whitelist = await context.createWhitelist(
-      whitelistKeypair,
-      context.taker.publicKey,
-      [newPubkey, context.dao.publicKey],
-      10
-    );
+    let whitelist = await context.createWhitelist(whitelistKeypair, context.taker.publicKey, [
+      newPubkey,
+      context.dao.publicKey,
+    ]);
 
     // create a two way RFQ specifying 1 bitcoin as a leg
     const rfq = await context.createRfq({

tests/unit/createWhitelist.ts

@@ -11,49 +11,31 @@ describe("Create Whitelist", () => {
   it("Create a whitelist", async () => {
     const whitelistKeypair = Keypair.generate();
 
-    await context.createWhitelist(
-      whitelistKeypair,
-      context.taker.publicKey,
-      [context.maker.publicKey, context.dao.publicKey],
-      10
-    );
+    await context.createWhitelist(whitelistKeypair, context.taker.publicKey, [
+      context.maker.publicKey,
+      context.dao.publicKey,
+    ]);
   });
 
-  it("Add an address to whitelist", async () => {
-    const whitelistKeypair = Keypair.generate();
-    const newPublickey = new PublicKey("Eyv3PBdmp5PUVzrT3orDVad8roBMK8au9nKBazZXkKtA");
-
-    const whitelist = await context.createWhitelist(
-      whitelistKeypair,
-      context.taker.publicKey,
-      [context.dao.publicKey, newPublickey],
-      50
-    );
-
-    await whitelist.addAddressToWhitelist(context.maker.publicKey);
-  });
+  it("Create a whitelist with MAX_WHITELIST_SIZE", async () => {
+    const pubkeys: PublicKey[] = [];
 
-  it("remove an address from whitelist", async () => {
+    for (let i = 0; i < 20; i++) {
+      const keypair = Keypair.generate();
+      pubkeys.push(keypair.publicKey);
+    }
     const whitelistKeypair = Keypair.generate();
 
-    const whitelist = await context.createWhitelist(
-      whitelistKeypair,
-      context.taker.publicKey,
-      [context.maker.publicKey, context.dao.publicKey],
-      10
-    );
-    await whitelist.removeAddressFromWhitelist(context.maker.publicKey);
+    await context.createWhitelist(whitelistKeypair, context.taker.publicKey, [...pubkeys]);
   });
 
   it("clean up", async () => {
     const whitelistKeypair = Keypair.generate();
 
-    const whitelist = await context.createWhitelist(
-      whitelistKeypair,
-      context.taker.publicKey,
-      [context.maker.publicKey, context.dao.publicKey],
-      10
-    );
+    const whitelist = await context.createWhitelist(whitelistKeypair, context.taker.publicKey, [
+      context.maker.publicKey,
+      context.dao.publicKey,
+    ]);
 
     await whitelist.cleanUp();
   });

tests/utilities/helpers.ts

@@ -256,7 +256,3 @@ export function addPubkeyExplanations(context: Context, input: string) {
 
   return result;
 }
-
-export function calculateWhitelistSize(expectedWhitelistCapacity: number) {
-  return 32 * expectedWhitelistCapacity;
-}