10836148456

Committed 12 Sep 2024 05:56PM UTC coverage: 13.841% (-0.1%) from 13.937%

Build # 10836148456

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9097 from clockworkgr/feat/govgen-support

feat: Adds support for govgen version of gov SDK module

Run Details

2991 of 20206 branches covered (14.8%)

Branch coverage included in aggregate %.

0 of 237 new or added lines in 8 files covered. (0.0%)

4 existing lines in 3 files now uncovered.

3977 of 30137 relevant lines covered (13.2%)

3.92 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/packages/commonwealth/client/scripts/controllers/chain/cosmos/gov/govgen/governance-v1beta1.ts

import { Any } from 'cosmjs-types/google/protobuf/any';

import type { ICosmosProposal } from 'controllers/chain/cosmos/types';
import { CosmosToken } from 'controllers/chain/cosmos/types';
import ProposalModule from 'models/ProposalModule';
import type { ITXModalData } from 'models/interfaces';
import type CosmosAccount from '../../account';
import type CosmosAccounts from '../../accounts';
import type CosmosChain from '../../chain';
import type { CosmosApiType } from '../../chain';
import { CosmosProposalGovgen } from './proposal-v1beta1';
import { encodeMsgSubmitProposal, msgToIProposal } from './utils-v1beta1';

/* CosmosGovernance v1beta1 */

class CosmosGovernanceGovgen extends ProposalModule<
  CosmosApiType,
  ICosmosProposal,
  // @ts-expect-error StrictNullChecks
  CosmosProposalGovgen
> {
  private _minDeposit: CosmosToken;
  public get minDeposit() {
    return this._minDeposit;
  }

  public setMinDeposit(minDeposit: CosmosToken) {
    this._minDeposit = minDeposit;
  }

  private _Chain: CosmosChain;
  private _Accounts: CosmosAccounts;

  /* eslint-disable-next-line @typescript-eslint/require-await */
  public async init(
    ChainInfo: CosmosChain,
    Accounts: CosmosAccounts,
  ): Promise<void> {
    this._Chain = ChainInfo;
    this._Accounts = Accounts;
    this._initialized = true;
  }

  public async getProposal(proposalId: number): Promise<CosmosProposalGovgen> {
    const existingProposal = this.store.getByIdentifier(proposalId);
    if (existingProposal) return existingProposal;
    return this._initProposal(proposalId);
  }

  private async _initProposal(
    proposalId: number,
    // @ts-expect-error StrictNullChecks
  ): Promise<CosmosProposalGovgen> {
    try {
      // @ts-expect-error StrictNullChecks
      if (!proposalId) return;
      const { proposal } = await this._Chain.api.govgen.proposal(proposalId);
      const cosmosProposal = new CosmosProposalGovgen(
        this._Chain,
        this._Accounts,
        this,
        // @ts-expect-error StrictNullChecks
        msgToIProposal(proposal),
      );
      cosmosProposal.init();
      return cosmosProposal;
    } catch (e) {
      console.error('Error fetching proposal: ', e);
    }
  }

  public createTx(
    sender: CosmosAccount,
    title: string,
    description: string,
    initialDeposit: CosmosToken,
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    memo = '',
  ): ITXModalData {
    throw new Error('unsupported');
  }

  // TODO: support multiple deposit types
  public async submitProposalTx(
    sender: CosmosAccount,
    initialDeposit: CosmosToken,
    content: Any,
  ): Promise<number> {
    const msg = encodeMsgSubmitProposal(
      sender.address,
      initialDeposit,
      content,
    );

    // fetch completed proposal from returned events
    const events = await this._Chain.sendTx(sender, msg);
    console.log(events);
    const submitEvent = events.find((e) => e.type === 'submit_proposal');
    const cosm = await import('@cosmjs/encoding');
    // @ts-expect-error StrictNullChecks
    const idAttribute = submitEvent.attributes.find(
      ({ key }) => cosm.fromAscii(key) === 'proposal_id',
    );
    // @ts-expect-error StrictNullChecks
    const id = +cosm.fromAscii(idAttribute.value);
    await this._initProposal(id);
    return id;
  }
}

export default CosmosGovernanceGovgen;

1	import { Any } from 'cosmjs-types/google/protobuf/any';
2
3	import type { ICosmosProposal } from 'controllers/chain/cosmos/types';
4	import { CosmosToken } from 'controllers/chain/cosmos/types';
5	import ProposalModule from 'models/ProposalModule';
6	import type { ITXModalData } from 'models/interfaces';
7	import type CosmosAccount from '../../account';
8	import type CosmosAccounts from '../../accounts';
9	import type CosmosChain from '../../chain';
10	import type { CosmosApiType } from '../../chain';
11	import { CosmosProposalGovgen } from './proposal-v1beta1';
12	import { encodeMsgSubmitProposal, msgToIProposal } from './utils-v1beta1';
13
14	/* CosmosGovernance v1beta1 */
15
16	class CosmosGovernanceGovgen extends ProposalModule<
17	CosmosApiType,
18	ICosmosProposal,
19	// @ts-expect-error StrictNullChecks
20	CosmosProposalGovgen
21	> {
22	private _minDeposit: CosmosToken;
23	public get minDeposit() {
NEW 24	return this._minDeposit;	×
25	}
26
27	public setMinDeposit(minDeposit: CosmosToken) {
NEW 28	this._minDeposit = minDeposit;	×
29	}
30
31	private _Chain: CosmosChain;
32	private _Accounts: CosmosAccounts;
33
34	/* eslint-disable-next-line @typescript-eslint/require-await */
35	public async init(
36	ChainInfo: CosmosChain,
37	Accounts: CosmosAccounts,
38	): Promise<void> {
NEW 39	this._Chain = ChainInfo;	×
NEW 40	this._Accounts = Accounts;	×
NEW 41	this._initialized = true;	×
42	}
43
44	public async getProposal(proposalId: number): Promise<CosmosProposalGovgen> {
NEW 45	const existingProposal = this.store.getByIdentifier(proposalId);	×
NEW 46	if (existingProposal) return existingProposal;	×
NEW 47	return this._initProposal(proposalId);	×
48	}
49
50	private async _initProposal(
51	proposalId: number,
52	// @ts-expect-error StrictNullChecks
53	): Promise<CosmosProposalGovgen> {
NEW 54	try {	×
55	// @ts-expect-error StrictNullChecks
NEW 56	if (!proposalId) return;	×
NEW 57	const { proposal } = await this._Chain.api.govgen.proposal(proposalId);	×
NEW 58	const cosmosProposal = new CosmosProposalGovgen(	×
59	this._Chain,
60	this._Accounts,
61	this,
62	// @ts-expect-error StrictNullChecks
63	msgToIProposal(proposal),
64	);
NEW 65	cosmosProposal.init();	×
NEW 66	return cosmosProposal;	×
67	} catch (e) {
NEW 68	console.error('Error fetching proposal: ', e);	×
69	}
70	}
71
72	public createTx(
73	sender: CosmosAccount,
74	title: string,
75	description: string,
76	initialDeposit: CosmosToken,
77	// eslint-disable-next-line @typescript-eslint/no-unused-vars
78	memo = '',	×
79	): ITXModalData {
NEW 80	throw new Error('unsupported');	×
81	}
82
83	// TODO: support multiple deposit types
84	public async submitProposalTx(
85	sender: CosmosAccount,
86	initialDeposit: CosmosToken,
87	content: Any,
88	): Promise<number> {
NEW 89	const msg = encodeMsgSubmitProposal(	×
90	sender.address,
91	initialDeposit,
92	content,
93	);
94
95	// fetch completed proposal from returned events
NEW 96	const events = await this._Chain.sendTx(sender, msg);	×
NEW 97	console.log(events);	×
NEW 98	const submitEvent = events.find((e) => e.type === 'submit_proposal');	×
NEW 99	const cosm = await import('@cosmjs/encoding');	×
100	// @ts-expect-error StrictNullChecks
NEW 101	const idAttribute = submitEvent.attributes.find(	×
NEW 102	({ key }) => cosm.fromAscii(key) === 'proposal_id',	×
103	);
104	// @ts-expect-error StrictNullChecks
NEW 105	const id = +cosm.fromAscii(idAttribute.value);	×
NEW 106	await this._initProposal(id);	×
NEW 107	return id;	×
108	}
109	}
110
111	export default CosmosGovernanceGovgen;

hicommonwealth / commonwealth / 10836148456

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous