feat: allow list features

Author: Jeday

features/defi-wrapper/pool-info.ts

@@ -6,9 +6,9 @@ import {
 import { callReadMethodSilent } from 'utils';
 import { reportFreshWarning } from 'features';
 
-const STV_POOL_NAME = 'StvPool';
-const STV_STETH_POOL_NAME = 'StvStETHPool';
-const STV_STRATEGY_POOL_NAME = 'StvStrategyPool';
+export const STV_POOL_NAME = 'StvPool';
+export const STV_STETH_POOL_NAME = 'StvStETHPool';
+export const STV_STRATEGY_POOL_NAME = 'StvStrategyPool';
 
 const getStvPoolInfo = async (address: Address) => {
   const contract = await getStvPoolContract(address);

programs/defi-wrapper/use-cases/wrapper-operations/read.ts

@@ -8,6 +8,7 @@ import {
   logResult,
   formatBP,
   callReadMethodSilent,
+  stringArrayToAddressArray,
 } from 'utils';
 import { getPoolInfo } from 'features/defi-wrapper/index.js';
 import { checkIsReportFresh } from 'features';
@@ -19,6 +20,7 @@ import {
 import { wrapperOperations } from './main.js';
 import { getDashboardContract, getStethContract } from 'contracts';
 import { bigIntMin } from 'utils/bigInt.js';
+import { getPublicClient } from 'providers';
 
 const wrapperOperationsRead = wrapperOperations
   .command('read')
@@ -117,6 +119,67 @@ wrapperOperationsRead
     });
   });
 
+wrapperOperationsRead
+  .command('allow-list')
+  .description('get full or partial allow list data')
+  .argument('<address>', 'wrapper address', stringToAddress)
+  .argument(
+    '[addresses...]',
+    'list of addresses to check, leave empty to get full allow list',
+    stringArrayToAddressArray,
+    [],
+  )
+  .action(async (poolAddress, addresses: Address[]) => {
+    const pool = await getStvPoolContract(poolAddress);
+    const publicClient = await getPublicClient();
+    const isAllowListEnabled = await callReadMethodSilent({
+      contract: pool,
+      methodName: 'ALLOW_LIST_ENABLED',
+      payload: [],
+    });
+    if (!isAllowListEnabled) {
+      logInfo('Allow List is disabled for this pool');
+      return;
+    }
+
+    const allowListSize = await callReadMethodSilent({
+      contract: pool,
+      methodName: 'getAllowListSize',
+      payload: [],
+    });
+    logInfo(`Allow List contains ${allowListSize} addresses:`);
+
+    if (addresses.length === 0) {
+      const fullAllowList = await callReadMethodSilent({
+        contract: pool,
+        methodName: 'getAllowListAddresses',
+        payload: [],
+      });
+
+      logTable({ data: fullAllowList.map((addr) => [addr]) });
+    } else {
+      const result = await publicClient.multicall({
+        contracts: addresses.map(
+          (address) =>
+            ({
+              address: pool.address,
+              abi: pool.abi,
+              functionName: 'isAllowListed',
+              args: [address],
+            }) as const,
+        ),
+        allowFailure: false,
+      });
+
+      logTable({
+        data: result.map((isAllowed, index) => [
+          addresses[index],
+          isAllowed ? '✅ Allowed' : '❌ Not Allowed',
+        ]),
+      });
+    }
+  });
+
 wrapperOperationsRead
   .command('report-fresh')
   .description('check if report is fresh')
@@ -144,7 +207,7 @@ const finalizationBlocker = (amount: bigint) => {
 wrapperOperationsRead
   .command('withdrawal-status')
   .description('get status of withdrawal queue')
-  .argument('<address>', 'wrapper address', stringToAddress)
+  .argument('<address>', 'wrapper address', stringArrayToAddressArray)
   .action(async (address: Address) => {
     const pool = await getStvPoolContract(address);
     const withdrawalQueueAddress = await callReadMethodSilent({

programs/defi-wrapper/use-cases/wrapper-operations/write.ts

@@ -8,13 +8,26 @@ import {
   confirmOperation,
   submitReport,
   callWriteMethodWithReceipt,
+  logError,
+  logTable,
+  callWriteMethodWithReceiptBatchCalls,
+  stringArrayToAddressArray,
 } from 'utils';
 import { wrapperOperations } from './main.js';
 import { getWithdrawalQueueContract } from 'contracts/defi-wrapper/withdrawal-queue.js';
-import { formatEther, zeroAddress, type Address } from 'viem';
+import {
+  encodeFunctionData,
+  formatEther,
+  fromHex,
+  parseEventLogs,
+  zeroAddress,
+  type Address,
+} from 'viem';
 import { getDashboardContract, getVaultHubContract } from 'contracts';
 import { getStvPoolContract } from 'contracts/defi-wrapper/stv-pool.js';
 import { bigIntMin } from 'utils/bigInt.js';
+import { getStvStethPoolContract } from 'contracts/defi-wrapper/stv-steth-pool.js';
+import { STV_STETH_POOL_NAME, STV_STRATEGY_POOL_NAME } from 'features';
 export const wrapperOperationsWrite = wrapperOperations
   .command('write')
   .aliases(['w'])
@@ -191,3 +204,147 @@ wrapperOperationsWrite
       });
     },
   );
+
+wrapperOperationsWrite
+  .command('sync-vault-params')
+  .description('sync vault params between vault & pool')
+  .argument('<poolAddress>', 'pool address', stringToAddress)
+  .action(async (address: Address) => {
+    const pool = await getStvStethPoolContract(address);
+
+    const poolType = await callReadMethod({
+      contract: pool,
+      methodName: 'poolType',
+      payload: [],
+    });
+
+    const poolTypeName = fromHex(poolType, 'string').replace(/\W/g, '');
+
+    const isStvStethPool =
+      poolTypeName === STV_STETH_POOL_NAME ||
+      poolTypeName === STV_STRATEGY_POOL_NAME;
+
+    if (!isStvStethPool) {
+      logError(
+        `The pool at address ${address} is not an StvStEth or StvStrategy pool. This operation is only applicable to StvStEth and StvStrategy pools.`,
+      );
+      return;
+    }
+
+    const { receipt } = await callWriteMethodWithReceipt({
+      contract: pool,
+      methodName: 'syncVaultParameters',
+      payload: [],
+    });
+
+    if (receipt?.logs) {
+      const logs = parseEventLogs({
+        abi: pool.abi,
+        logs: receipt.logs,
+        strict: true,
+      });
+
+      const hadEffect = logs.find(
+        (log) => log.eventName === 'VaultParametersUpdated',
+      );
+
+      if (!hadEffect) {
+        logInfo(
+          '⚠️⚠️⚠️ Vault parameters are already in sync. No changes were made during your tx. ⚠️⚠️⚠️',
+        );
+        return;
+      }
+    }
+  });
+
+wrapperOperationsWrite
+  .command('allow-list-add')
+  .description('add addresses(divided by spaces) to allow list ')
+  .argument('<poolAddress>', 'pool address', stringToAddress)
+  .argument(
+    '<addressToAdd...>',
+    '1 or more addresses to add to allow list divided by spaces',
+    stringArrayToAddressArray,
+    [],
+  )
+  .action(async (address: Address, addressToAdd: Address[]) => {
+    const pool = await getStvPoolContract(address);
+    const isAllowListEnabled = await callReadMethod({
+      contract: pool,
+      methodName: 'ALLOW_LIST_ENABLED',
+      payload: [],
+    });
+
+    if (!isAllowListEnabled) {
+      logError('Pool is not configured for using allow list.');
+      return;
+    }
+
+    logTable({
+      data: addressToAdd.map((addr) => [addr]),
+      params: { head: ['Addresses to be added to allow list:'] },
+    });
+
+    const confirm = await confirmOperation(
+      `Are you sure you want to add  ${addressToAdd.length} addresses to the allow list of the pool at address: ${address}?`,
+    );
+    if (!confirm) return;
+
+    await callWriteMethodWithReceiptBatchCalls({
+      calls: addressToAdd.map((addr) => ({
+        to: pool.address,
+        data: encodeFunctionData({
+          abi: pool.abi,
+          functionName: 'addToAllowList',
+          args: [addr],
+        }),
+        value: 0n,
+      })),
+    });
+  });
+
+wrapperOperationsWrite
+  .command('allow-list-remove')
+  .description('remove addresses(divided by spaces) from allow list ')
+  .argument('<poolAddress>', 'pool address', stringToAddress)
+  .argument(
+    '[addressesToRemove...]',
+    '1 or more addresses to remove divided by spaces',
+    stringArrayToAddressArray,
+    [],
+  )
+  .action(async (address: Address, addressesToRemove: Address[]) => {
+    const pool = await getStvPoolContract(address);
+    const isAllowListEnabled = await callReadMethod({
+      contract: pool,
+      methodName: 'ALLOW_LIST_ENABLED',
+      payload: [],
+    });
+
+    if (!isAllowListEnabled) {
+      logError('Pool is not configured for using allow list.');
+      return;
+    }
+
+    logTable({
+      data: addressesToRemove.map((addr) => [addr]),
+      params: { head: ['Addresses to be removed from allow list:'] },
+    });
+
+    const confirm = await confirmOperation(
+      `Are you sure you want to remove ${addressesToRemove.length} addresses from the allow list of the pool at address: ${address}?`,
+    );
+    if (!confirm) return;
+
+    await callWriteMethodWithReceiptBatchCalls({
+      calls: addressesToRemove.map((addr) => ({
+        to: pool.address,
+        data: encodeFunctionData({
+          abi: pool.abi,
+          functionName: 'removeFromAllowList',
+          args: [addr],
+        }),
+        value: 0n,
+      })),
+    });
+  });

utils/arguments.ts

@@ -196,6 +196,13 @@ export const stringToAddress = (value: string): Address => {
   return value;
 };
 
+export const stringArrayToAddressArray = (
+  value: string,
+  previous: Address[],
+) => {
+  return previous.concat([stringToAddress(value)]);
+};
+
 export const stringToHash = (value: string): Hex => {
   if (!isHex(value)) {
     program.error('Hash value must be a valid hash', { exitCode: 1 });