stargate: Rearrange bank query extension

2025-03-11 14:09:15 +00:00 · 2021-03-30 18:00:30 +02:00 · 2021-03-30 18:00:30 +02:00 · c414aad304
commit c414aad304
parent 774bab681b
5 changed files with 155 additions and 143 deletions
--- a/packages/stargate/src/queries/bank.spec.ts
+++ b/packages/stargate/src/queries/bank.spec.ts
@ -37,39 +37,125 @@ describe("BankExtension", () => {
      tmClient.disconnect();
    });

-    it("returns null for non-existent balance", async () => {
+    it("returns zero for non-existent balance", async () => {
      pendingWithoutSimapp();
      const [client, tmClient] = await makeClientWithBank(simapp.tendermintUrl);

      const response = await client.bank.balance(unused.address, "gintonic");
-      expect(response).toBeNull();
+      expect(response).toEqual({
+        amount: "0",
+        denom: "gintonic",
+      });

      tmClient.disconnect();
    });

-    it("returns null for non-existent address", async () => {
+    it("returns zero for non-existent address", async () => {
      pendingWithoutSimapp();
      const [client, tmClient] = await makeClientWithBank(simapp.tendermintUrl);

      const response = await client.bank.balance(nonExistentAddress, simapp.denomFee);
-      expect(response).toBeNull();
+      expect(response).toEqual({
+        amount: "0",
+        denom: simapp.denomFee,
+      });

      tmClient.disconnect();
    });
  });

-  describe("unverified", () => {
+  describe("allBalances", () => {
+    it("returns all balances for unused account", async () => {
+      pendingWithoutSimapp();
+      const [client, tmClient] = await makeClientWithBank(simapp.tendermintUrl);
+
+      const balances = await client.bank.allBalances(unused.address);
+      expect(balances).toEqual([
+        {
+          amount: unused.balanceFee,
+          denom: simapp.denomFee,
+        },
+        {
+          amount: unused.balanceStaking,
+          denom: simapp.denomStaking,
+        },
+      ]);
+
+      tmClient.disconnect();
+    });
+
+    it("returns an empty list for non-existent account", async () => {
+      pendingWithoutSimapp();
+      const [client, tmClient] = await makeClientWithBank(simapp.tendermintUrl);
+
+      const balances = await client.bank.allBalances(nonExistentAddress);
+      expect(balances).toEqual([]);
+
+      tmClient.disconnect();
+    });
+  });
+
+  describe("totalSupply", () => {
+    it("works", async () => {
+      pendingWithoutSimapp();
+      const [client, tmClient] = await makeClientWithBank(simapp.tendermintUrl);
+
+      const response = await client.bank.totalSupply();
+      expect(response).toEqual([
+        {
+          amount: simapp.totalSupply.toString(),
+          denom: simapp.denomFee,
+        },
+        {
+          amount: jasmine.stringMatching(nonNegativeIntegerMatcher),
+          denom: simapp.denomStaking,
+        },
+      ]);
+
+      tmClient.disconnect();
+    });
+  });
+
+  describe("supplyOf", () => {
+    it("works for existing denom", async () => {
+      pendingWithoutSimapp();
+      const [client, tmClient] = await makeClientWithBank(simapp.tendermintUrl);
+
+      const response = await client.bank.supplyOf(simapp.denomFee);
+      expect(response).toEqual({
+        amount: simapp.totalSupply.toString(),
+        denom: simapp.denomFee,
+      });
+
+      tmClient.disconnect();
+    });
+
+    it("returns zero for non-existent denom", async () => {
+      pendingWithoutSimapp();
+      const [client, tmClient] = await makeClientWithBank(simapp.tendermintUrl);
+
+      const response = await client.bank.supplyOf("gintonic");
+      expect(response).toEqual({
+        amount: "0",
+        denom: "gintonic",
+      });
+
+      tmClient.disconnect();
+    });
+  });
+
+  describe("verified", () => {
    describe("balance", () => {
      it("works for different existing balances", async () => {
        pendingWithoutSimapp();
        const [client, tmClient] = await makeClientWithBank(simapp.tendermintUrl);

-        const response1 = await client.bank.unverified.balance(unused.address, simapp.denomFee);
+        const response1 = await client.bank.verified.balance(unused.address, simapp.denomFee);
        expect(response1).toEqual({
          amount: unused.balanceFee,
          denom: simapp.denomFee,
        });
-        const response2 = await client.bank.unverified.balance(unused.address, simapp.denomStaking);
+        const response2 = await client.bank.verified.balance(unused.address, simapp.denomStaking);
        expect(response2).toEqual({
          amount: unused.balanceStaking,
          denom: simapp.denomStaking,
@ -78,108 +164,22 @@ describe("BankExtension", () => {
        tmClient.disconnect();
      });

-      it("returns zero for non-existent balance", async () => {
+      it("returns null for non-existent balance", async () => {
        pendingWithoutSimapp();
        const [client, tmClient] = await makeClientWithBank(simapp.tendermintUrl);

-        const response = await client.bank.unverified.balance(unused.address, "gintonic");
-        expect(response).toEqual({
-          amount: "0",
-          denom: "gintonic",
-        });
+        const response = await client.bank.verified.balance(unused.address, "gintonic");
+        expect(response).toBeNull();

        tmClient.disconnect();
      });

-      it("returns zero for non-existent address", async () => {
+      it("returns null for non-existent address", async () => {
        pendingWithoutSimapp();
        const [client, tmClient] = await makeClientWithBank(simapp.tendermintUrl);

-        const response = await client.bank.unverified.balance(nonExistentAddress, simapp.denomFee);
-        expect(response).toEqual({
-          amount: "0",
-          denom: simapp.denomFee,
-        });
-
-        tmClient.disconnect();
-      });
-    });
-
-    describe("allBalances", () => {
-      it("returns all balances for unused account", async () => {
-        pendingWithoutSimapp();
-        const [client, tmClient] = await makeClientWithBank(simapp.tendermintUrl);
-
-        const balances = await client.bank.unverified.allBalances(unused.address);
-        expect(balances).toEqual([
-          {
-            amount: unused.balanceFee,
-            denom: simapp.denomFee,
-          },
-          {
-            amount: unused.balanceStaking,
-            denom: simapp.denomStaking,
-          },
-        ]);
-
-        tmClient.disconnect();
-      });
-
-      it("returns an empty list for non-existent account", async () => {
-        pendingWithoutSimapp();
-        const [client, tmClient] = await makeClientWithBank(simapp.tendermintUrl);
-
-        const balances = await client.bank.unverified.allBalances(nonExistentAddress);
-        expect(balances).toEqual([]);
-
-        tmClient.disconnect();
-      });
-    });
-
-    describe("totalSupply", () => {
-      it("works", async () => {
-        pendingWithoutSimapp();
-        const [client, tmClient] = await makeClientWithBank(simapp.tendermintUrl);
-
-        const response = await client.bank.unverified.totalSupply();
-        expect(response).toEqual([
-          {
-            amount: simapp.totalSupply.toString(),
-            denom: simapp.denomFee,
-          },
-          {
-            amount: jasmine.stringMatching(nonNegativeIntegerMatcher),
-            denom: simapp.denomStaking,
-          },
-        ]);
-
-        tmClient.disconnect();
-      });
-    });
-
-    describe("supplyOf", () => {
-      it("works for existing denom", async () => {
-        pendingWithoutSimapp();
-        const [client, tmClient] = await makeClientWithBank(simapp.tendermintUrl);
-
-        const response = await client.bank.unverified.supplyOf(simapp.denomFee);
-        expect(response).toEqual({
-          amount: simapp.totalSupply.toString(),
-          denom: simapp.denomFee,
-        });
-
-        tmClient.disconnect();
-      });
-
-      it("returns zero for non-existent denom", async () => {
-        pendingWithoutSimapp();
-        const [client, tmClient] = await makeClientWithBank(simapp.tendermintUrl);
-
-        const response = await client.bank.unverified.supplyOf("gintonic");
-        expect(response).toEqual({
-          amount: "0",
-          denom: "gintonic",
-        });
+        const response = await client.bank.verified.balance(nonExistentAddress, simapp.denomFee);
+        expect(response).toBeNull();

        tmClient.disconnect();
      });
--- a/packages/stargate/src/queries/bank.ts
+++ b/packages/stargate/src/queries/bank.ts
@ -9,12 +9,12 @@ import { createProtobufRpcClient, toAccAddress } from "./utils";

 export interface BankExtension {
  readonly bank: {
-    readonly balance: (address: string, denom: string) => Promise<Coin | null>;
-    readonly unverified: {
-      readonly balance: (address: string, denom: string) => Promise<Coin>;
-      readonly allBalances: (address: string) => Promise<Coin[]>;
-      readonly totalSupply: () => Promise<Coin[]>;
-      readonly supplyOf: (denom: string) => Promise<Coin>;
+    readonly balance: (address: string, denom: string) => Promise<Coin>;
+    readonly allBalances: (address: string) => Promise<Coin[]>;
+    readonly totalSupply: () => Promise<Coin[]>;
+    readonly supplyOf: (denom: string) => Promise<Coin>;
+    readonly verified: {
+      readonly balance: (address: string, denom: string) => Promise<Coin | null>;
    };
  };
 }
@ -28,34 +28,34 @@ export function setupBankExtension(base: QueryClient): BankExtension {
  return {
    bank: {
      balance: async (address: string, denom: string) => {
-        // balance key is a bit tricker, using some prefix stores
-        // https://github.com/cosmwasm/cosmos-sdk/blob/80f7ff62f79777a487d0c7a53c64b0f7e43c47b9/x/bank/keeper/view.go#L74-L77
-        // ("balances", binAddress, denom)
-        // it seem like prefix stores just do a dumb concat with the keys (no tricks to avoid overlap)
-        // https://github.com/cosmos/cosmos-sdk/blob/2879c0702c87dc9dd828a8c42b9224dc054e28ad/store/prefix/store.go#L61-L64
-        // https://github.com/cosmos/cosmos-sdk/blob/2879c0702c87dc9dd828a8c42b9224dc054e28ad/store/prefix/store.go#L37-L43
-        const key = Uint8Array.from([...toAscii("balances"), ...toAccAddress(address), ...toAscii(denom)]);
-        const responseData = await base.queryVerified("bank", key);
-        return responseData.length ? Coin.decode(responseData) : null;
+        const { balance } = await queryService.Balance({ address: address, denom: denom });
+        assert(balance);
+        return balance;
      },
-      unverified: {
+      allBalances: async (address: string) => {
+        const { balances } = await queryService.AllBalances({ address: address });
+        return balances;
+      },
+      totalSupply: async () => {
+        const { supply } = await queryService.TotalSupply({});
+        return supply;
+      },
+      supplyOf: async (denom: string) => {
+        const { amount } = await queryService.SupplyOf({ denom: denom });
+        assert(amount);
+        return amount;
+      },
+      verified: {
        balance: async (address: string, denom: string) => {
-          const { balance } = await queryService.Balance({ address: address, denom: denom });
-          assert(balance);
-          return balance;
-        },
-        allBalances: async (address: string) => {
-          const { balances } = await queryService.AllBalances({ address: address });
-          return balances;
-        },
-        totalSupply: async () => {
-          const { supply } = await queryService.TotalSupply({});
-          return supply;
-        },
-        supplyOf: async (denom: string) => {
-          const { amount } = await queryService.SupplyOf({ denom: denom });
-          assert(amount);
-          return amount;
+          // balance key is a bit tricker, using some prefix stores
+          // https://github.com/cosmwasm/cosmos-sdk/blob/80f7ff62f79777a487d0c7a53c64b0f7e43c47b9/x/bank/keeper/view.go#L74-L77
+          // ("balances", binAddress, denom)
+          // it seem like prefix stores just do a dumb concat with the keys (no tricks to avoid overlap)
+          // https://github.com/cosmos/cosmos-sdk/blob/2879c0702c87dc9dd828a8c42b9224dc054e28ad/store/prefix/store.go#L61-L64
+          // https://github.com/cosmos/cosmos-sdk/blob/2879c0702c87dc9dd828a8c42b9224dc054e28ad/store/prefix/store.go#L37-L43
+          const key = Uint8Array.from([...toAscii("balances"), ...toAccAddress(address), ...toAscii(denom)]);
+          const responseData = await base.queryVerified("bank", key);
+          return responseData.length ? Coin.decode(responseData) : null;
        },
      },
    },
--- a/packages/stargate/src/signingstargateclient.spec.ts
+++ b/packages/stargate/src/signingstargateclient.spec.ts
@ -241,7 +241,10 @@ describe("SigningStargateClient", () => {

      // no tokens here
      const before = await client.getBalance(beneficiaryAddress, "ucosm");
-      expect(before).toBeNull();
+      expect(before).toEqual({
+        denom: "ucosm",
+        amount: "0",
+      });

      // send
      const result = await client.sendTokens(faucet.address0, beneficiaryAddress, transferAmount, memo);
@ -265,7 +268,10 @@ describe("SigningStargateClient", () => {

      // no tokens here
      const before = await client.getBalance(beneficiaryAddress, "ucosm");
-      expect(before).toBeNull();
+      expect(before).toEqual({
+        denom: "ucosm",
+        amount: "0",
+      });

      // send
      const result = await client.sendTokens(faucet.address0, beneficiaryAddress, transferAmount, memo);
--- a/packages/stargate/src/stargateclient.spec.ts
+++ b/packages/stargate/src/stargateclient.spec.ts
@ -213,33 +213,39 @@ describe("StargateClient", () => {
      client.disconnect();
    });

-    it("returns null for non-existent balance", async () => {
+    it("returns 0 for non-existent balance", async () => {
      pendingWithoutSimapp();
      const client = await StargateClient.connect(simapp.tendermintUrl);

      const response = await client.getBalance(unused.address, "gintonic");
-      expect(response).toBeNull();
+      expect(response).toEqual({
+        denom: "gintonic",
+        amount: "0",
+      });

      client.disconnect();
    });

-    it("returns null for non-existent address", async () => {
+    it("returns 0 for non-existent address", async () => {
      pendingWithoutSimapp();
      const client = await StargateClient.connect(simapp.tendermintUrl);

      const response = await client.getBalance(nonExistentAddress, simapp.denomFee);
-      expect(response).toBeNull();
+      expect(response).toEqual({
+        denom: simapp.denomFee,
+        amount: "0",
+      });

      client.disconnect();
    });
  });

-  describe("getAllBalancesUnverified", () => {
+  describe("getAllBalances", () => {
    it("returns all balances for unused account", async () => {
      pendingWithoutSimapp();
      const client = await StargateClient.connect(simapp.tendermintUrl);

-      const balances = await client.getAllBalancesUnverified(unused.address);
+      const balances = await client.getAllBalances(unused.address);
      expect(balances).toEqual([
        {
          amount: unused.balanceFee,
@ -258,7 +264,7 @@ describe("StargateClient", () => {
      pendingWithoutSimapp();
      const client = await StargateClient.connect(simapp.tendermintUrl);

-      const balances = await client.getAllBalancesUnverified(nonExistentAddress);
+      const balances = await client.getAllBalances(nonExistentAddress);
      expect(balances).toEqual([]);

      client.disconnect();
--- a/packages/stargate/src/stargateclient.ts
+++ b/packages/stargate/src/stargateclient.ts
@ -207,7 +207,7 @@ export class StargateClient {
    };
  }

-  public async getBalance(address: string, searchDenom: string): Promise<Coin | null> {
+  public async getBalance(address: string, searchDenom: string): Promise<Coin> {
    return this.forceGetQueryClient().bank.balance(address, searchDenom);
  }

@ -217,8 +217,8 @@ export class StargateClient {
   * Uses the grpc queries (which iterates over the store internally), and we cannot get
   * proofs from such a method.
   */
-  public async getAllBalancesUnverified(address: string): Promise<readonly Coin[]> {
-    return this.forceGetQueryClient().bank.unverified.allBalances(address);
+  public async getAllBalances(address: string): Promise<readonly Coin[]> {
+    return this.forceGetQueryClient().bank.allBalances(address);
  }

  public async getTx(id: string): Promise<IndexedTx | null> {