feat: add 'contracts query balance' subcommand

Author: eliasmpw

src/arguments/contract.ts

@@ -4,14 +4,26 @@ import { sanitizeDirName } from '@/utils';
 
 const ContractArgumentDescription = 'Name of the contract';
 
+/**
+ * Definition of Contract name optional argument
+ */
+export const definitionContractNameOptional = {
+  parse: async (val: string): Promise<string> => sanitizeDirName(val),
+  description: ContractArgumentDescription,
+};
+
+/**
+ * Contract name optional argument
+ */
+export const contractNameOptional = Args.string(definitionContractNameOptional);
+
 /**
  * Definition of Contract name required argument
  */
-export const definitionContractNameRequired = Args.string({
+export const definitionContractNameRequired = {
+  ...definitionContractNameOptional,
   required: true,
-  parse: async val => sanitizeDirName(val),
-  description: ContractArgumentDescription,
-});
+};
 
 /**
  * Contract name required argument

src/commands/contracts/execute.ts

@@ -61,7 +61,7 @@ export default class ContractsExecute extends BaseCommand<typeof ContractsExecut
     const accountsDomain = await Accounts.init(this.flags['keyring-backend'] as BackendType, { filesPath: this.flags['keyring-path'] });
     const fromAccount: AccountWithMnemonic = await accountsDomain.getWithMnemonic(this.flags.from!);
 
-    const instantiated = await config.contractsInstance.findInstantiateDeployment(this.args.contract!, config.chainId);
+    const instantiated = config.contractsInstance.findInstantiateDeployment(this.args.contract!, config.chainId);
 
     if (!instantiated) throw new NotFoundError('Instantiated deployment with a contract address');
 

src/commands/contracts/instantiate.ts

@@ -75,7 +75,7 @@ export default class ContractsInstantiate extends BaseCommand<typeof ContractsIn
     // If code id is not set as flag, try to get it from deployments history
     let codeId = this.flags.code;
     if (!codeId) {
-      codeId = (await config.contractsInstance.findStoreDeployment(this.args.contract!, config.chainId))?.wasm.codeId;
+      codeId = (config.contractsInstance.findStoreDeployment(this.args.contract!, config.chainId))?.wasm.codeId;
 
       if (!codeId) throw new NotFoundError("Code id of contract's store deployment");
     }

src/commands/contracts/metadata.ts

@@ -41,7 +41,7 @@ export default class ContractsMetadata extends BaseCommand<typeof ContractsMetad
     const accountsDomain = await Accounts.init(this.flags['keyring-backend'] as BackendType, { filesPath: this.flags['keyring-path'] });
     const fromAccount: AccountWithMnemonic = await accountsDomain.getWithMnemonic(this.flags.from!);
 
-    const instantiated = await config.contractsInstance.findInstantiateDeployment(this.args.contract!, config.chainId);
+    const instantiated = config.contractsInstance.findInstantiateDeployment(this.args.contract!, config.chainId);
 
     if (!instantiated) throw new NotFoundError('Instantiated deployment with a contract address');
 

src/commands/contracts/migrate.ts

@@ -55,7 +55,7 @@ export default class ContractsMigrate extends BaseCommand<typeof ContractsMigrat
     const accountsDomain = await Accounts.init(this.flags['keyring-backend'] as BackendType, { filesPath: this.flags['keyring-path'] });
     const fromAccount: AccountWithMnemonic = await accountsDomain.getWithMnemonic(this.flags.from!);
 
-    const instantiated = await config.contractsInstance.findInstantiateDeployment(this.args.contract!, config.chainId);
+    const instantiated = config.contractsInstance.findInstantiateDeployment(this.args.contract!, config.chainId);
 
     if (!instantiated) throw new NotFoundError('Instantiated deployment with a contract address');
 

src/commands/contracts/premium.ts

@@ -39,7 +39,7 @@ export default class ContractsPremium extends BaseCommand<typeof ContractsPremiu
     const accountsDomain = await Accounts.init(this.flags['keyring-backend'] as BackendType, { filesPath: this.flags['keyring-path'] });
     const fromAccount: AccountWithMnemonic = await accountsDomain.getWithMnemonic(this.flags.from!);
 
-    const instantiated = await config.contractsInstance.findInstantiateDeployment(this.args.contract!, config.chainId);
+    const instantiated = config.contractsInstance.findInstantiateDeployment(this.args.contract!, config.chainId);
 
     if (!instantiated) throw new NotFoundError('Instantiated deployment with a contract address');
 

src/commands/contracts/query/balance.ts

@@ -0,0 +1,68 @@
+import { Args, Flags } from '@oclif/core';
+
+import { BaseCommand } from '@/lib/base';
+import { definitionContractNameOptional } from '@/arguments';
+import { Config } from '@/domain';
+import { showSpinner } from '@/ui';
+import { NotFoundError } from '@/exceptions';
+
+import { InstantiateDeployment } from '@/types';
+
+/**
+ * Command 'contracts query balance'
+ * Access the bank module to query the balance of contracts
+ */
+export default class ContractsQuerySmart extends BaseCommand<typeof ContractsQuerySmart> {
+  static summary = 'Access the bank module to query the balance of contracts';
+  static args = {
+    contract: Args.string({ ...definitionContractNameOptional }),
+  };
+
+  static flags = {
+    all: Flags.boolean({
+      description: 'Shows the balance of all contracts',
+      default: false,
+    }),
+  };
+
+  /**
+   * Runs the command.
+   *
+   * @returns Empty promise
+   */
+  public async run(): Promise<void> {
+    if (!this.args.contract && !this.flags.all) {
+      throw new NotFoundError('Contract name or --all flag');
+    }
+
+    // Load config and contract info
+    const config = await Config.open();
+    await config.contractsInstance.assertValidWorkspace();
+
+    let contractsToQuery: InstantiateDeployment[] = [];
+
+    if (this.flags.all) {
+      contractsToQuery = config.contractsInstance.getAllInstantiateDeployments(config.chainId);
+    } else {
+      const instantiated = config.contractsInstance.findInstantiateDeployment(this.args.contract!, config.chainId);
+
+      contractsToQuery = instantiated ? [instantiated] : [];
+    }
+
+    if (contractsToQuery.length === 0) throw new NotFoundError('Instantiated contract with a contract address');
+
+    const result = await showSpinner(async () => {
+      const client = await config.getStargateClient();
+
+      return config.contractsInstance.queryAllBalances(client, contractsToQuery);
+    }, 'Querying contract balances...');
+
+    if (this.jsonEnabled()) {
+      this.logJson({ contracts: result });
+    } else {
+      for (const item of result) {
+        this.log(`${config.contractsInstance.prettyPrintBalances(item)}`);
+      }
+    }
+  }
+}

src/commands/contracts/query/smart.ts

@@ -55,7 +55,7 @@ export default class ContractsQuerySmart extends BaseCommand<typeof ContractsQue
     const accountsDomain = await Accounts.init(this.flags['keyring-backend'] as BackendType, { filesPath: this.flags['keyring-path'] });
     const fromAccount: AccountWithMnemonic = await accountsDomain.getWithMnemonic(this.flags.from!);
 
-    const instantiated = await config.contractsInstance.findInstantiateDeployment(this.args.contract!, config.chainId);
+    const instantiated = config.contractsInstance.findInstantiateDeployment(this.args.contract!, config.chainId);
 
     if (!instantiated) throw new NotFoundError('Instantiated deployment with a contract address');
 

src/domain/Contracts.ts

@@ -4,9 +4,10 @@ import fs from 'node:fs/promises';
 import toml from 'toml';
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
+import { Coin, StargateClient } from '@cosmjs/stargate';
 
-import { readSubDirectories, getWorkspaceRoot, bold, green, red } from '@/utils';
-import { Contract } from '@/types';
+import { readSubDirectories, getWorkspaceRoot, bold, green, red, darkGreen, yellow } from '@/utils';
+import { AccountBalancesJSON, Contract } from '@/types';
 import { DEFAULT, REPOSITORIES } from '@/GlobalConfig';
 import { Cargo, Deployments } from '@/domain';
 import { ErrorCodes, ExecuteError, InstantiateError, NotFoundError, QueryError } from '@/exceptions';
@@ -320,9 +321,9 @@ export class Contracts {
    *
    * @param contractName - Name of the contract to search by
    * @param chainId - Chain id to search by
-   * @returns Promise containing an instance of {@link StoreDeployment} or undefined if not found
+   * @returns An instance of {@link StoreDeployment} or undefined if not found
    */
-  async findStoreDeployment(contractName: string, chainId: string): Promise<StoreDeployment | undefined> {
+  findStoreDeployment(contractName: string, chainId: string): StoreDeployment | undefined {
     const contract = this.assertGetContractByName(contractName);
 
     return contract.deployments.find(item => {
@@ -339,9 +340,9 @@ export class Contracts {
    *
    * @param contractName - Name of the contract to search by
    * @param chainId - Chain id to search by
-   * @returns Promise containing an instance of {@link InstantiateDeployment} or undefined if not found
+   * @returns An instance of {@link InstantiateDeployment} or undefined if not found
    */
-  async findInstantiateDeployment(contractName: string, chainId: string): Promise<InstantiateDeployment | undefined> {
+  findInstantiateDeployment(contractName: string, chainId: string): InstantiateDeployment | undefined {
     const contract = this.assertGetContractByName(contractName);
 
     return contract.deployments.find(item => {
@@ -354,6 +355,62 @@ export class Contracts {
       );
     }) as InstantiateDeployment | undefined;
   }
+
+  /**
+   * Returns a list of all the last instantiated deployments of all contracts
+   *
+   * @param chainId - Chain id to search by
+   * @returns An array of instances of {@link InstantiateDeployment}
+   */
+  getAllInstantiateDeployments(chainId: string): InstantiateDeployment[] {
+    const instantiatedDeployments = this._data.map(
+      contract =>
+        contract.deployments.find(item => {
+          const pastDeploy = item as InstantiateDeployment;
+
+          return (
+            pastDeploy.contract.version === contract.version &&
+            pastDeploy.action === DeploymentAction.INSTANTIATE &&
+            pastDeploy.chainId === chainId
+          );
+        }) as InstantiateDeployment | undefined
+    );
+
+    return instantiatedDeployments.filter(item => item !== undefined) as InstantiateDeployment[];
+  }
+
+  /**
+   * Query the balance of contracts
+   *
+   * @param client - Stargate client to use when querying
+   * @param instantiateDeployements - An array of instances of {@link InstantiateDeployment} to query
+   * @returns Promise containing the balances result
+   */
+  async queryAllBalances(client: StargateClient, instantiatedDeployments: InstantiateDeployment[]): Promise<AccountBalancesJSON[]> {
+    const balances = await Promise.all(instantiatedDeployments.map(item => client.getAllBalances(item.contract.address)));
+
+    return instantiatedDeployments.map((item, index) => ({
+      account: {
+        name: item.contract.name,
+        address: item.contract.address,
+        balances: balances[index] as Coin[],
+      },
+    }));
+  }
+
+  /**
+   * Get a formatted version of a contract balance
+   *
+   * @param balance - Contract balance data
+   * @returns Formatted contract address balance
+   */
+  prettyPrintBalances(balance: AccountBalancesJSON): string {
+    let result = `Balances for contract ${green(balance.account.name)} (${darkGreen(balance.account.address)})\n\n`;
+    if (balance.account.balances.length === 0) result += `- ${yellow('Empty balance')}\n`;
+    for (const item of balance.account.balances) result += `- ${bold(item.amount)}${item.denom}\n`;
+
+    return result;
+  }
 }
 
 /**

test/commands/contracts/execute.test.ts

@@ -45,7 +45,7 @@ describe('contracts execute', () => {
     validateSchemaStub = sinon.stub(Contracts.prototype, <any>'assertValidJSONSchema').callsFake(async () => {});
     findInstantiateStub = sinon
       .stub(Contracts.prototype, 'findInstantiateDeployment')
-      .callsFake(async () => instantiateDeployment as InstantiateDeployment);
+      .callsFake(() => instantiateDeployment as InstantiateDeployment);
     signingClientStub = sinon
       .stub(SigningArchwayClient, 'connectWithSigner')
       .callsFake(async () => ({ execute: async () => dummyExecuteTransaction } as any));
@@ -63,27 +63,24 @@ describe('contracts execute', () => {
     findInstantiateStub.restore();
     signingClientStub.restore();
   });
-  describe('Executes a transaction in a contract', () => {
-    test
-      .stdout()
-      .command(['contracts execute', contractName, '--args={}', `--from=${aliceAccountName}`])
-      .it('Sets smart contract premium', ctx => {
-        expect(ctx.stdout).to.contain('Executed contract');
-        expect(ctx.stdout).to.contain(contractName);
-        expect(ctx.stdout).to.contain('Transaction:');
-        expect(ctx.stdout).to.contain(dummyExecuteTransaction.transactionHash);
-      });
-  });
 
-  describe('Prints json output', () => {
-    test
-      .stdout()
-      .command(['contracts execute', contractName, '--args={}', `--from=${aliceAccountName}`, '--json'])
-      .it('Sets smart contract premium', ctx => {
-        expect(ctx.stdout).to.not.contain('Executed contract');
-        expect(ctx.stdout).to.contain(dummyExecuteTransaction.transactionHash);
-        expect(ctx.stdout).to.contain(dummyExecuteTransaction.gasWanted);
-        expect(ctx.stdout).to.contain(dummyExecuteTransaction.gasUsed);
-      });
-  });
+  test
+    .stdout()
+    .command(['contracts execute', contractName, '--args={}', `--from=${aliceAccountName}`])
+    .it('Executes a transaction in a contract', ctx => {
+      expect(ctx.stdout).to.contain('Executed contract');
+      expect(ctx.stdout).to.contain(contractName);
+      expect(ctx.stdout).to.contain('Transaction:');
+      expect(ctx.stdout).to.contain(dummyExecuteTransaction.transactionHash);
+    });
+
+  test
+    .stdout()
+    .command(['contracts execute', contractName, '--args={}', `--from=${aliceAccountName}`, '--json'])
+    .it('Prints json output', ctx => {
+      expect(ctx.stdout).to.not.contain('Executed contract');
+      expect(ctx.stdout).to.contain(dummyExecuteTransaction.transactionHash);
+      expect(ctx.stdout).to.contain(dummyExecuteTransaction.gasWanted);
+      expect(ctx.stdout).to.contain(dummyExecuteTransaction.gasUsed);
+    });
 });