Sort methods in RestClient

packages/sdk/src/restclient.spec.ts

@@ -169,15 +169,61 @@ describe("RestClient", () => {
     expect(client).toBeTruthy();
   });
 
-  describe("nodeInfo", () => {
-    it("works", async () => {
+  // The /auth endpoints
+
+  describe("authAccounts", () => {
+    it("works for unused account without pubkey", async () => {
       pendingWithoutWasmd();
       const client = new RestClient(httpUrl);
-      const info = await client.nodeInfo();
-      expect(info.node_info.network).toEqual(defaultNetworkId);
+      const { result } = await client.authAccounts(unusedAccount.address);
+      expect(result).toEqual({
+        type: "cosmos-sdk/Account",
+        value: {
+          address: unusedAccount.address,
+          public_key: "", // not known to the chain
+          coins: [
+            {
+              amount: "1000000000",
+              denom: "ucosm",
+            },
+            {
+              amount: "1000000000",
+              denom: "ustake",
+            },
+          ],
+          account_number: 5,
+          sequence: 0,
+        },
+      });
+    });
+
+    // This fails in the first test run if you forget to run `./scripts/wasmd/init.sh`
+    it("has correct pubkey for faucet", async () => {
+      pendingWithoutWasmd();
+      const client = new RestClient(httpUrl);
+      const { result } = await client.authAccounts(faucet.address);
+      expect(result.value).toEqual(
+        jasmine.objectContaining({
+          public_key: encodeBech32Pubkey(faucet.pubkey, "cosmospub"),
+        }),
+      );
+    });
+
+    // This property is used by CosmWasmClient.getAccount
+    it("returns empty address for non-existent account", async () => {
+      pendingWithoutWasmd();
+      const client = new RestClient(httpUrl);
+      const nonExistentAccount = makeRandomAddress();
+      const { result } = await client.authAccounts(nonExistentAccount);
+      expect(result).toEqual({
+        type: "cosmos-sdk/Account",
+        value: jasmine.objectContaining({ address: "" }),
+      });
     });
   });
 
+  // The /blocks endpoints
+
   describe("blocksLatest", () => {
     it("works", async () => {
       pendingWithoutWasmd();
@@ -245,57 +291,19 @@ describe("RestClient", () => {
     });
   });
 
-  describe("authAccounts", () => {
-    it("works for unused account without pubkey", async () => {
-      pendingWithoutWasmd();
-      const client = new RestClient(httpUrl);
-      const { result } = await client.authAccounts(unusedAccount.address);
-      expect(result).toEqual({
-        type: "cosmos-sdk/Account",
-        value: {
-          address: unusedAccount.address,
-          public_key: "", // not known to the chain
-          coins: [
-            {
-              amount: "1000000000",
-              denom: "ucosm",
-            },
-            {
-              amount: "1000000000",
-              denom: "ustake",
-            },
-          ],
-          account_number: 5,
-          sequence: 0,
-        },
-      });
-    });
+  // The /node_info endpoint
 
-    // This fails in the first test run if you forget to run `./scripts/wasmd/init.sh`
-    it("has correct pubkey for faucet", async () => {
+  describe("nodeInfo", () => {
+    it("works", async () => {
       pendingWithoutWasmd();
       const client = new RestClient(httpUrl);
-      const { result } = await client.authAccounts(faucet.address);
-      expect(result.value).toEqual(
-        jasmine.objectContaining({
-          public_key: encodeBech32Pubkey(faucet.pubkey, "cosmospub"),
-        }),
-      );
-    });
-
-    // This property is used by CosmWasmClient.getAccount
-    it("returns empty address for non-existent account", async () => {
-      pendingWithoutWasmd();
-      const client = new RestClient(httpUrl);
-      const nonExistentAccount = makeRandomAddress();
-      const { result } = await client.authAccounts(nonExistentAccount);
-      expect(result).toEqual({
-        type: "cosmos-sdk/Account",
-        value: jasmine.objectContaining({ address: "" }),
-      });
+      const info = await client.nodeInfo();
+      expect(info.node_info.network).toEqual(defaultNetworkId);
     });
   });
 
+  // The /txs endpoints
+
   describe("encodeTx", () => {
     it("works for cosmoshub example", async () => {
       pendingWithoutWasmd();
@@ -304,7 +312,7 @@ describe("RestClient", () => {
     });
   });
 
-  describe("post", () => {
+  describe("postTx", () => {
     it("can send tokens", async () => {
       pendingWithoutWasmd();
       const pen = await Secp256k1Pen.fromMnemonic(faucet.mnemonic);
@@ -410,6 +418,8 @@ describe("RestClient", () => {
     });
   });
 
+  // The /wasm endpoints
+
   describe("query", () => {
     it("can list upload code", async () => {
       pendingWithoutWasmd();

packages/sdk/src/restclient.ts

@@ -235,14 +235,19 @@ export class RestClient {
     return data;
   }
 
-  public async nodeInfo(): Promise<NodeInfoResponse> {
-    const responseData = await this.get("/node_info");
-    if (!(responseData as any).node_info) {
+  // The /auth endpoints
+
+  public async authAccounts(address: string): Promise<AuthAccountsResponse> {
+    const path = `/auth/accounts/${address}`;
+    const responseData = await this.get(path);
+    if ((responseData as any).result.type !== "cosmos-sdk/Account") {
       throw new Error("Unexpected response data format");
     }
-    return responseData as NodeInfoResponse;
+    return responseData as AuthAccountsResponse;
   }
 
+  // The /blocks endpoints
+
   public async blocksLatest(): Promise<BlockResponse> {
     const responseData = await this.get("/blocks/latest");
     if (!(responseData as any).block) {
@@ -259,6 +264,18 @@ export class RestClient {
     return responseData as BlockResponse;
   }
 
+  // The /node_info endpoint
+
+  public async nodeInfo(): Promise<NodeInfoResponse> {
+    const responseData = await this.get("/node_info");
+    if (!(responseData as any).node_info) {
+      throw new Error("Unexpected response data format");
+    }
+    return responseData as NodeInfoResponse;
+  }
+
+  // The /txs endpoints
+
   /** returns the amino-encoding of the transaction performed by the server */
   public async encodeTx(tx: CosmosSdkTx): Promise<Uint8Array> {
     const responseData = await this.post("/txs/encode", tx);
@@ -268,15 +285,6 @@ export class RestClient {
     return Encoding.fromBase64((responseData as EncodeTxResponse).tx);
   }
 
-  public async authAccounts(address: string): Promise<AuthAccountsResponse> {
-    const path = `/auth/accounts/${address}`;
-    const responseData = await this.get(path);
-    if ((responseData as any).result.type !== "cosmos-sdk/Account") {
-      throw new Error("Unexpected response data format");
-    }
-    return responseData as AuthAccountsResponse;
-  }
-
   public async txs(query: string): Promise<SearchTxsResponse> {
     const responseData = await this.get(`/txs?${query}`);
     if (!(responseData as any).txs) {
@@ -293,7 +301,13 @@ export class RestClient {
     return responseData as TxsResponse;
   }
 
-  // tx must be JSON encoded StdTx (no wrapper)
+  /**
+   * Broadcasts a signed transaction to into the transaction pool.
+   * Depending on the RestClient's broadcast mode, this might or might
+   * wait for checkTx or deliverTx to be executed before returning.
+   *
+   * @param tx must be JSON encoded StdTx (no wrapper)
+   */
   public async postTx(tx: Uint8Array): Promise<PostTxsResponse> {
     // TODO: check this is StdTx
     const decoded = JSON.parse(fromUtf8(tx));
@@ -311,6 +325,8 @@ export class RestClient {
     return responseData as PostTxsResponse;
   }
 
+  // The /wasm endpoints
+
   // wasm rest queries are listed here: https://github.com/cosmwasm/wasmd/blob/master/x/wasm/client/rest/query.go#L19-L27
   public async listCodeInfo(): Promise<readonly CodeInfo[]> {
     const path = `/wasm/code`;

packages/sdk/types/restclient.d.ts

@@ -124,14 +124,21 @@ export declare class RestClient {
   constructor(url: string, mode?: BroadcastMode);
   get(path: string): Promise<RestClientResponse>;
   post(path: string, params: PostTxsParams): Promise<RestClientResponse>;
-  nodeInfo(): Promise<NodeInfoResponse>;
+  authAccounts(address: string): Promise<AuthAccountsResponse>;
   blocksLatest(): Promise<BlockResponse>;
   blocks(height: number): Promise<BlockResponse>;
+  nodeInfo(): Promise<NodeInfoResponse>;
   /** returns the amino-encoding of the transaction performed by the server */
   encodeTx(tx: CosmosSdkTx): Promise<Uint8Array>;
-  authAccounts(address: string): Promise<AuthAccountsResponse>;
   txs(query: string): Promise<SearchTxsResponse>;
   txsById(id: string): Promise<TxsResponse>;
+  /**
+   * Broadcasts a signed transaction to into the transaction pool.
+   * Depending on the RestClient's broadcast mode, this might or might
+   * wait for checkTx or deliverTx to be executed before returning.
+   *
+   * @param tx must be JSON encoded StdTx (no wrapper)
+   */
   postTx(tx: Uint8Array): Promise<PostTxsResponse>;
   listCodeInfo(): Promise<readonly CodeInfo[]>;
   getCode(id: number): Promise<Uint8Array>;