Merge remote-tracking branch 'origin/main' into feat/slinky

Author: NeverHappened

src/helpers/gaia.ts

@@ -3,11 +3,19 @@ import {
   MsgDelegate,
   MsgUndelegate,
 } from '@neutron-org/neutronjsplus/dist/proto/cosmos_sdk/cosmos/staking/v1beta1/tx_pb';
+import {
+  MsgSubmitProposal,
+  MsgVote,
+} from '@neutron-org/neutronjsplus/dist/proto/cosmos_sdk/cosmos/gov/v1beta1/tx_pb';
 import {
   packAnyMsg,
   WalletWrapper,
 } from '@neutron-org/neutronjsplus/dist/cosmos';
 import Long from 'long';
+import {
+  TextProposal,
+  VoteOption,
+} from '@neutron-org/neutronjsplus/dist/proto/cosmos_sdk/cosmos/gov/v1beta1/gov_pb';
 
 export const msgDelegate = async (
   wallet: WalletWrapper,
@@ -48,5 +56,56 @@ export const msgUndelegate = async (
     },
     [packAnyMsg('/cosmos.staking.v1beta1.MsgUndelegate', msgUndelegate)],
   );
+
+  return res?.tx_response;
+};
+
+export const msgSubmitProposal = async (
+  wallet: WalletWrapper,
+  proposer: string,
+  amount = '0',
+): Promise<BroadcastTx200ResponseTxResponse> => {
+  const msgSubmitProposal = new MsgSubmitProposal({
+    proposer,
+    content: {
+      typeUrl: '/cosmos.gov.v1beta1.TextProposal',
+      value: new TextProposal({
+        title: 'mock',
+        description: 'mock',
+      }).toBinary(),
+    },
+    initialDeposit: [{ denom: wallet.chain.denom, amount: '10000000' }],
+  });
+  const res = await wallet.execTx(
+    {
+      gas_limit: Long.fromString('500000'),
+      amount: [{ denom: wallet.chain.denom, amount: amount }],
+    },
+    [packAnyMsg('/cosmos.gov.v1beta1.MsgSubmitProposal', msgSubmitProposal)],
+  );
+
+  return res?.tx_response;
+};
+
+export const msgVote = async (
+  wallet: WalletWrapper,
+  voter: string,
+  proposalId: number,
+  amount = '0',
+): Promise<BroadcastTx200ResponseTxResponse> => {
+  const msgVote = new MsgVote({
+    voter,
+    proposalId: BigInt(proposalId),
+    option: VoteOption.YES,
+  });
+
+  const res = await wallet.execTx(
+    {
+      gas_limit: Long.fromString('500000'),
+      amount: [{ denom: wallet.chain.denom, amount: amount }],
+    },
+    [packAnyMsg('/cosmos.gov.v1beta1.MsgVote', msgVote)],
+  );
+
   return res?.tx_response;
 };

src/testcases/parallel/overrule.test.ts

@@ -16,7 +16,7 @@ import {
 
 const config = require('../../config.json');
 
-describe('Neutron / Subdao', () => {
+describe('Neutron / Subdao Overrule', () => {
   let testState: TestStateLocalCosmosTestNet;
   let neutronChain: CosmosWrapper;
   let neutronAccount1: WalletWrapper;

src/testcases/parallel/subdao.test.ts

@@ -18,10 +18,16 @@ import {
   TimelockConfig,
   TimelockProposalListResponse,
 } from '@neutron-org/neutronjsplus/dist/dao';
-import { Wallet } from '@neutron-org/neutronjsplus/dist/types';
+import {
+  SingleChoiceProposal,
+  Wallet,
+} from '@neutron-org/neutronjsplus/dist/types';
 import { BroadcastTx200ResponseTxResponse } from '@cosmos-client/core/cjs/openapi/api';
 import cosmosclient from '@cosmos-client/core';
-import { waitSeconds } from '@neutron-org/neutronjsplus/dist/wait';
+import {
+  getWithAttempts,
+  waitSeconds,
+} from '@neutron-org/neutronjsplus/dist/wait';
 import {
   paramChangeProposal,
   sendProposal,
@@ -480,6 +486,86 @@ describe('Neutron / Subdao', () => {
     });
   });
 
+  describe('Timelock3: Closed overruled proposal should not prevent execution', () => {
+    let proposalId: number;
+    beforeAll(async () => {
+      proposalId = await subdaoMember1.submitUpdateSubDaoConfigProposal(
+        {
+          name: 'dao name after timelock3',
+        },
+        'single2',
+      );
+
+      // move proposal to the timelocked state where it can be overruled
+      const timelockedProp = await subdaoMember1.supportAndExecuteProposal(
+        proposalId,
+        'single2',
+      );
+
+      expect(timelockedProp.id).toEqual(proposalId);
+      expect(timelockedProp.status).toEqual('timelocked');
+      expect(timelockedProp.msgs).toHaveLength(1);
+    });
+
+    test('close rejected overrule proposal', async () => {
+      const overruleProposalId = await mainDao.getOverruleProposalId(
+        subDao.contracts.proposals.single2.pre_propose.timelock!.address,
+        proposalId,
+      );
+
+      // wait 20 seconds
+      await waitSeconds(20);
+
+      const propOverruledTest =
+        await mainDao.chain.queryContract<SingleChoiceProposal>(
+          mainDaoMember.dao.contracts.proposals.overrule?.address,
+          {
+            proposal: {
+              proposal_id: overruleProposalId,
+            },
+          },
+        );
+      expect(propOverruledTest.proposal.status).toEqual('rejected');
+
+      await subdaoMember1.user.executeContract(
+        mainDaoMember.dao.contracts.proposals.overrule.address,
+        JSON.stringify({
+          close: { proposal_id: overruleProposalId },
+        }),
+      );
+
+      const propOverruledTest2 = await getWithAttempts(
+        neutronChain.blockWaiter,
+        async () =>
+          await mainDao.chain.queryContractWithWait<SingleChoiceProposal>(
+            mainDaoMember.dao.contracts.proposals.overrule?.address,
+            {
+              proposal: {
+                proposal_id: overruleProposalId,
+              },
+            },
+          ),
+        async (p) => p.proposal.status === 'closed',
+        5,
+      );
+
+      expect(propOverruledTest2.proposal.status).toEqual('closed');
+    });
+
+    test('execute timelocked: success', async () => {
+      await waitSeconds(20);
+      await subdaoMember1.executeTimelockedProposal(proposalId, 'single2');
+
+      const timelockedProp = await subDao.getTimelockedProposal(
+        proposalId,
+        'single2',
+      );
+      expect(timelockedProp.id).toEqual(proposalId);
+      expect(timelockedProp.status).toEqual('executed');
+      expect(timelockedProp.msgs).toHaveLength(1);
+    });
+  });
+
   describe('Non-timelock typed duration pause proposal: Succeed creation', () => {
     let proposalId: number;