feat: whitelist tf hooks

package.json

@@ -47,7 +47,7 @@
     "@cosmos-client/core": "^0.47.4",
     "@cosmos-client/cosmwasm": "^0.40.3",
     "@cosmos-client/ibc": "^1.2.1",
-    "@neutron-org/neutronjsplus": "0.4.1",
+    "@neutron-org/neutronjsplus": "neutron-org/neutronjsplus#feat/whitelist-tf-hooks",
     "@types/lodash": "^4.14.182",
     "@types/long": "^5.0.0",
     "axios": "^0.27.2",
@@ -93,4 +93,4 @@
   "engines": {
     "node": ">=16.0 <17"
   }
-}
+}

src/testcases/parallel/tokenfactory.test.ts

@@ -5,6 +5,7 @@ import {
   NEUTRON_DENOM,
   getEventAttribute,
 } from '@neutron-org/neutronjsplus/dist/cosmos';
+import cosmosclient from '@cosmos-client/core';
 import { TestStateLocalCosmosTestNet } from '@neutron-org/neutronjsplus';
 import { NeutronContract, Wallet } from '@neutron-org/neutronjsplus/dist/types';
 import {
@@ -13,19 +14,70 @@ import {
   msgCreateDenom,
   msgMintDenom,
   msgSetBeforeSendHook,
+  getBeforeSendHook,
   getDenomsFromCreator,
   checkTokenfactoryParams,
   getAuthorityMetadata,
-  getBeforeSendHook,
 } from '@neutron-org/neutronjsplus/dist/tokenfactory';
+import {
+  Dao,
+  DaoMember,
+  getDaoContracts,
+  setupSubDaoTimelockSet,
+} from '@neutron-org/neutronjsplus/dist/dao';
+import { updateTokenfactoryParamsProposal } from '@neutron-org/neutronjsplus/dist/proposal';
+import { waitSeconds } from '@neutron-org/neutronjsplus/dist/wait';
 
 const config = require('../../config.json');
 
+async function whitelistTokenfactoryHook(
+  neutronChain: CosmosWrapper,
+  subDao: Dao,
+  subdaoMember1: DaoMember,
+  codeID: number,
+  denomCreator: string,
+) {
+  const chainManagerAddress = (await neutronChain.getChainAdmins())[0];
+  const proposalId = await subdaoMember1.submitUpdateParamsTokenfactoryProposal(
+    chainManagerAddress,
+    'whitelist proposal',
+    'whitelist tokenfactory hook. Will pass',
+    updateTokenfactoryParamsProposal({
+      denom_creation_fee: [],
+      denom_creation_gas_consume: 0,
+      fee_collector_address: '',
+      whitelisted_hooks: [
+        {
+          code_id: codeID,
+          denom_creator: denomCreator,
+        },
+      ],
+    }),
+    '1000',
+  );
+
+  let timelockedProp = await subdaoMember1.supportAndExecuteProposal(
+    proposalId,
+  );
+  await waitSeconds(10);
+
+  await subdaoMember1.executeTimelockedProposal(proposalId);
+  timelockedProp = await subDao.getTimelockedProposal(proposalId);
+  expect(timelockedProp.id).toEqual(proposalId);
+  expect(timelockedProp.status).toEqual('executed');
+}
+
 describe('Neutron / Tokenfactory', () => {
   let testState: TestStateLocalCosmosTestNet;
   let neutronChain: CosmosWrapper;
   let neutronAccount: WalletWrapper;
   let ownerWallet: Wallet;
+  let subDao: Dao;
+  let mainDao: Dao;
+  let subdaoMember1: DaoMember;
+  let mainDaoMember: DaoMember;
+  let securityDaoWallet: Wallet;
+  let securityDaoAddr: cosmosclient.AccAddress | cosmosclient.ValAddress;
 
   beforeAll(async () => {
     testState = new TestStateLocalCosmosTestNet(config);
@@ -37,6 +89,56 @@ describe('Neutron / Tokenfactory', () => {
       NEUTRON_DENOM,
     );
     neutronAccount = new WalletWrapper(neutronChain, ownerWallet);
+
+    // Setup subdao with update tokenfactory params
+    const daoCoreAddress = await neutronChain.getNeutronDAOCore();
+    const daoContracts = await getDaoContracts(neutronChain, daoCoreAddress);
+    securityDaoWallet = testState.wallets.qaNeutronThree.genQaWal1;
+    securityDaoAddr = securityDaoWallet.address;
+
+    mainDao = new Dao(neutronChain, daoContracts);
+    mainDaoMember = new DaoMember(neutronAccount, mainDao);
+    await mainDaoMember.bondFunds('10000');
+
+    subDao = await setupSubDaoTimelockSet(
+      neutronAccount,
+      mainDao.contracts.core.address,
+      securityDaoAddr.toString(),
+      true,
+    );
+
+    subdaoMember1 = new DaoMember(neutronAccount, subDao);
+
+    const chainManagerAddress = (await neutronChain.getChainAdmins())[0];
+    const proposalId =
+      await mainDaoMember.submitAddChainManagerStrategyProposal(
+        chainManagerAddress,
+        'Proposal #1',
+        'Add strategy proposal. It will pass',
+        {
+          add_strategy: {
+            address: subDao.contracts.core.address,
+            strategy: {
+              allow_only: [
+                {
+                  update_tokenfactory_params_permission: {
+                    denom_creation_fee: true,
+                    denom_creation_gas_consume: true,
+                    fee_collector_address: true,
+                    whitelisted_hooks: true,
+                  },
+                },
+              ],
+            },
+          },
+        },
+        '1000',
+      );
+
+    await mainDaoMember.voteYes(proposalId);
+    await mainDao.checkPassedProposal(proposalId);
+    await waitSeconds(10);
+    await mainDaoMember.executeProposalWithAttempts(proposalId);
   });
 
   test('tokenfactory module is added', async () => {
@@ -245,6 +347,14 @@ describe('Neutron / Tokenfactory', () => {
       expect(queryTrack.track.received).toEqual(false);
       expect(queryBlock.block.received).toEqual(false);
 
+      await whitelistTokenfactoryHook(
+        neutronChain,
+        subDao,
+        subdaoMember1,
+        codeId,
+        ownerWallet.address.toString(),
+      );
+
       await msgSetBeforeSendHook(
         neutronAccount,
         ownerWallet.address.toString(),
@@ -298,11 +408,10 @@ describe('Neutron / Tokenfactory', () => {
     let denom: string;
     let amount = 10000000;
     const toBurn = 1000000;
+    let codeId;
 
     test('setup contract', async () => {
-      const codeId = await neutronAccount.storeWasm(
-        NeutronContract.TOKENFACTORY,
-      );
+      codeId = await neutronAccount.storeWasm(NeutronContract.TOKENFACTORY);
       expect(codeId).toBeGreaterThan(0);
 
       const res = await neutronAccount.instantiateContract(
@@ -327,7 +436,6 @@ describe('Neutron / Tokenfactory', () => {
           },
         }),
       );
-      console.log(JSON.stringify(res.events));
       denom = res.events
         ?.find((event) => event.type == 'create_denom')
         ?.attributes?.find(
@@ -429,8 +537,15 @@ describe('Neutron / Tokenfactory', () => {
       );
       expect(res.admin).toEqual(contractAddress);
     });
-
     test('set_before_send_hook', async () => {
+      await whitelistTokenfactoryHook(
+        neutronChain,
+        subDao,
+        subdaoMember1,
+        codeId,
+        contractAddress,
+      );
+
       await neutronAccount.executeContract(
         contractAddress,
         JSON.stringify({

src/testcases/run_in_band/chain_manager.test.ts

@@ -15,7 +15,10 @@ import {
 import { Wallet } from '@neutron-org/neutronjsplus/dist/types';
 import cosmosclient from '@cosmos-client/core';
 import { waitSeconds } from '@neutron-org/neutronjsplus/dist/wait';
-import { updateCronParamsProposal } from '@neutron-org/neutronjsplus/dist/proposal';
+import {
+  updateCronParamsProposal,
+  updateTokenfactoryParamsProposal,
+} from '@neutron-org/neutronjsplus/dist/proposal';
 
 import config from '../../config.json';
 
@@ -128,7 +131,7 @@ describe('Neutron / Chain Manager', () => {
     });
   });
 
-  describe('Add an ALLOW_ONLY strategy (Cron module parameter updates, legacy param changes)', () => {
+  describe('Add an ALLOW_ONLY strategy (Cron module parameter updates, Tokenfactory module parameter updates, legacy param changes)', () => {
     let proposalId: number;
     test('create proposal', async () => {
       const chainManagerAddress = (await neutronChain.getChainAdmins())[0];
@@ -152,11 +155,17 @@ describe('Neutron / Chain Manager', () => {
                   },
                 },
                 {
-                  update_params_permission: {
-                    cron_update_params_permission: {
-                      security_address: true,
-                      limit: true,
-                    },
+                  update_cron_params_permission: {
+                    security_address: true,
+                    limit: true,
+                  },
+                },
+                {
+                  update_tokenfactory_params_permission: {
+                    denom_creation_fee: true,
+                    denom_creation_gas_consume: true,
+                    fee_collector_address: true,
+                    whitelisted_hooks: true,
                   },
                 },
               ],
@@ -219,4 +228,64 @@ describe('Neutron / Chain Manager', () => {
       expect(cronParams.params.limit).toEqual('42');
     });
   });
+
+  describe('ALLOW_ONLY: change TOKENFACTORY parameters', () => {
+    let proposalId: number;
+    beforeAll(async () => {
+      const chainManagerAddress = (await neutronChain.getChainAdmins())[0];
+      proposalId = await subdaoMember1.submitUpdateParamsTokenfactoryProposal(
+        chainManagerAddress,
+        'Proposal #2',
+        'Cron update params proposal. Will pass',
+        updateTokenfactoryParamsProposal({
+          denom_creation_fee: [{ denom: 'untrn', amount: '1' }],
+          denom_creation_gas_consume: 20,
+          fee_collector_address:
+            'neutron1m9l358xunhhwds0568za49mzhvuxx9ux8xafx2',
+          whitelisted_hooks: [
+            {
+              code_id: 1,
+              denom_creator: 'neutron1m9l358xunhhwds0568za49mzhvuxx9ux8xafx2',
+            },
+          ],
+        }),
+        '1000',
+      );
+
+      const timelockedProp = await subdaoMember1.supportAndExecuteProposal(
+        proposalId,
+      );
+
+      expect(timelockedProp.id).toEqual(proposalId);
+      expect(timelockedProp.status).toEqual('timelocked');
+      expect(timelockedProp.msgs).toHaveLength(1);
+    });
+
+    test('execute timelocked: success', async () => {
+      await waitSeconds(10);
+
+      await subdaoMember1.executeTimelockedProposal(proposalId);
+      const timelockedProp = await subDao.getTimelockedProposal(proposalId);
+      expect(timelockedProp.id).toEqual(proposalId);
+      expect(timelockedProp.status).toEqual('executed');
+      expect(timelockedProp.msgs).toHaveLength(1);
+
+      const tokenfactoryParams = await neutronChain.queryTokenfactoryParams();
+      expect(tokenfactoryParams.params.denom_creation_fee).toEqual([
+        { denom: 'untrn', amount: '1' },
+      ]);
+      expect(tokenfactoryParams.params.denom_creation_gas_consume).toEqual(
+        '20',
+      );
+      expect(tokenfactoryParams.params.fee_collector_address).toEqual(
+        'neutron1m9l358xunhhwds0568za49mzhvuxx9ux8xafx2',
+      );
+      expect(tokenfactoryParams.params.whitelisted_hooks).toEqual([
+        {
+          code_id: '1',
+          denom_creator: 'neutron1m9l358xunhhwds0568za49mzhvuxx9ux8xafx2',
+        },
+      ]);
+    });
+  });
 });

src/testcases/run_in_band/parameters.test.ts

@@ -129,7 +129,7 @@ describe('Neutron / Parameters', () => {
         'Tokenfactory params proposal',
         updateTokenfacoryParamsProposal({
           fee_collector_address: await neutronChain.getNeutronDAOCore(),
-          denom_creation_fee: null,
+          denom_creation_fee: [{ denom: 'untrn', amount: '1' }],
           denom_creation_gas_consume: 100000,
         }),
         '1000',
@@ -156,13 +156,18 @@ describe('Neutron / Parameters', () => {
       test('check if params changed after proposal execution', async () => {
         const paramsAfter = await neutronChain.queryTokenfactoryParams();
 
-        expect(paramsAfter.params.denom_creation_fee).toEqual(
+        expect(paramsAfter.params.denom_creation_fee).not.toEqual(
           paramsBefore.params.denom_creation_fee,
         );
         expect(paramsAfter.params.denom_creation_gas_consume).not.toEqual(
           paramsBefore.params.denom_creation_gas_consume,
         );
-        expect(paramsAfter.params.denom_creation_fee).toHaveLength(0);
+        expect(paramsAfter.params.denom_creation_fee).toEqual([
+          {
+            denom: 'untrn',
+            amount: '1',
+          },
+        ]);
         expect(paramsAfter.params.denom_creation_gas_consume).toEqual('100000');
       });
     });

yarn.lock

@@ -1568,10 +1568,9 @@
   resolved "https://registry.yarnpkg.com/@ledgerhq/logs/-/logs-5.50.0.tgz#29c6419e8379d496ab6d0426eadf3c4d100cd186"
   integrity sha512-swKHYCOZUGyVt4ge0u8a7AwNcA//h4nx5wIi0sruGye1IJ5Cva0GyK9L2/WdX+kWVTKp92ZiEo1df31lrWGPgA==
 
-"@neutron-org/[email protected]":
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/@neutron-org/neutronjsplus/-/neutronjsplus-0.4.1.tgz#5e7b6e8f0ea63873719ae9011103c297c3eca209"
-  integrity sha512-CyRAxai2Pk8tpU+0cUEGGchwwf2wBa8wfCPWJRf07PRTvBJ06sEYMfJqW0kdUtLuBc9tqEt4DD2IGfGkOrVwyg==
+"@neutron-org/neutronjsplus@neutron-org/neutronjsplus#feat/whitelist-tf-hooks":
+  version "0.4.0-rc19"
+  resolved "https://codeload.github.com/neutron-org/neutronjsplus/tar.gz/891da6c41e0801fa8e5422d166c835df5f41eef8"
   dependencies:
     "@bufbuild/protobuf" "^1.4.2"
     "@cosmos-client/core" "^0.47.4"