test: add unit tests

packages/arch3-core/src/archwayclient.ts

@@ -3,7 +3,6 @@ import { CosmWasmClient } from '@cosmjs/cosmwasm-stargate';
 import { EncodeObject } from '@cosmjs/proto-signing';
 import {
   HttpEndpoint,
-  RpcClient,
   HttpBatchClient,
   HttpBatchClientOptions,
   CometClient,

packages/arch3-core/src/modules/authz/tx.spec.ts

@@ -0,0 +1,81 @@
+import { GenericAuthorization } from 'cosmjs-types/cosmos/authz/v1beta1/authz';
+import { MsgGrant, MsgRevoke } from 'cosmjs-types/cosmos/authz/v1beta1/tx';
+import { SendAuthorization } from 'cosmjs-types/cosmos/bank/v1beta1/authz';
+import { MsgWithdrawDelegatorReward } from 'cosmjs-types/cosmos/distribution/v1beta1/tx';
+
+import { createAuthzAminoConverters } from '.';
+
+const aminoConverters = createAuthzAminoConverters();
+
+const archwayd = {
+  chainId: 'local-1',
+  endpoint: 'http://localhost:26657',
+  prefix: 'archway',
+  denom: process.env.DENOM || 'aarch',
+};
+
+const granterAddress = 'archway1ecak50zhujddqd639xw4ejghnyrrc6jlwnlgwt';
+const granteeAddress = 'archway1vrzhff4gnnye4qt37stn9v6xker333cdew6xdt';
+
+describe('Amino converter for /cosmos.authz.v1beta1.MsgGrant', () => {
+  describe('Grants generic authorization with /cosmos.authz.v1beta1.GenericAuthorization', () => {
+    it('encodes and decodes back to the same value', () => {
+      const message = {
+        granter: granterAddress,
+        grantee: granteeAddress,
+        grant: {
+          authorization: {
+            typeUrl: GenericAuthorization.typeUrl,
+            value: GenericAuthorization.encode(
+              GenericAuthorization.fromPartial({
+                msg: MsgWithdrawDelegatorReward.typeUrl,
+              }),
+            ).finish(),
+          },
+          expiration: undefined,
+        },
+      };
+      const toAmino = aminoConverters[MsgGrant.typeUrl].toAmino(message);
+      const result = aminoConverters[MsgGrant.typeUrl].fromAmino(toAmino);
+
+      expect(message).toStrictEqual(result);
+    });
+  });
+  describe('Grants generic authorization with /cosmos.authz.v1beta1.SendAuthorization', () => {
+    it('encodes and decodes back to the same value', () => {
+      const message = {
+        granter: granterAddress,
+        grantee: granteeAddress,
+        grant: {
+          authorization: {
+            typeUrl: SendAuthorization.typeUrl,
+            value: SendAuthorization.encode(
+              SendAuthorization.fromPartial({
+                spendLimit: [{ denom: archwayd.denom, amount: '1' }],
+              }),
+            ).finish(),
+          },
+          expiration: undefined,
+        },
+      };
+      const toAmino = aminoConverters[MsgGrant.typeUrl].toAmino(message);
+      const result = aminoConverters[MsgGrant.typeUrl].fromAmino(toAmino);
+
+      expect(message).toStrictEqual(result);
+    });
+  });
+});
+
+describe('Amino converter for /cosmos.authz.v1beta1.MsgRevoke', () => {
+  it('encodes and decodes back to the same value', () => {
+    const message = {
+      granter: granterAddress,
+      grantee: granteeAddress,
+      msgTypeUrl: MsgWithdrawDelegatorReward.typeUrl,
+    };
+    const toAmino = aminoConverters[MsgRevoke.typeUrl].toAmino(message);
+    const result = aminoConverters[MsgRevoke.typeUrl].fromAmino(toAmino);
+
+    expect(message).toStrictEqual(result);
+  });
+});

packages/arch3-core/src/modules/authz/tx.ts

@@ -1,44 +1,48 @@
-import { AminoConverters } from "@cosmjs/stargate";
-import { GenericAuthorization } from "cosmjs-types/cosmos/authz/v1beta1/authz";
-import { MsgGrant, MsgRevoke } from "cosmjs-types/cosmos/authz/v1beta1/tx";
-import { SendAuthorization } from "cosmjs-types/cosmos/bank/v1beta1/authz";
-import { Timestamp } from "cosmjs-types/google/protobuf/timestamp";
-import { fromJsonTimestamp, fromTimestamp } from "cosmjs-types/helpers";
+import { AminoConverters } from '@cosmjs/stargate';
+import { GenericAuthorization } from 'cosmjs-types/cosmos/authz/v1beta1/authz';
+import { MsgGrant, MsgRevoke } from 'cosmjs-types/cosmos/authz/v1beta1/tx';
+import { SendAuthorization } from 'cosmjs-types/cosmos/bank/v1beta1/authz';
+import { Timestamp } from 'cosmjs-types/google/protobuf/timestamp';
+import { fromJsonTimestamp, fromTimestamp } from 'cosmjs-types/helpers';
 
-export function createAuthzAminoConverters(): AminoConverters {
+/**
+ * Creates the Amino converters for the Authz tx messages
+ *
+ * @returns to be used in a client
+ */
+export const createAuthzAminoConverters = (): AminoConverters => {
   return {
     [MsgGrant.typeUrl]: {
-      aminoType: "cosmos-sdk/MsgGrant",
+      aminoType: 'cosmos-sdk/MsgGrant',
       toAmino: ({ granter, grantee, grant }) => {
         if (!grant || !grant.authorization) {
           throw new Error(`Unsupported grant type: '${grant?.authorization?.typeUrl}'`);
         }
         let authorizationValue;
         switch (grant?.authorization?.typeUrl) {
-          case GenericAuthorization.typeUrl: {
-            const generic = GenericAuthorization.decode(grant.authorization.value);
-            authorizationValue = {
-              type: "cosmos-sdk/GenericAuthorization",
-              value: {
-                msg: generic.msg,
-              },
-            };
-            break;
-          }
-          case SendAuthorization.typeUrl: {
-            const spend = SendAuthorization.decode(grant.authorization.value);
-            authorizationValue = {
-              type: "cosmos-sdk/SendAuthorization",
-              value: {
-                spend_limit: spend.spendLimit,
-              },
-            };
-            break;
-          }
-          default:
-            throw new Error(`Unsupported grant type: '${grant.authorization.typeUrl}'`);
+        case GenericAuthorization.typeUrl: {
+          const generic = GenericAuthorization.decode(grant.authorization.value);
+          authorizationValue = {
+            type: 'cosmos-sdk/GenericAuthorization',
+            value: {
+              msg: generic.msg,
+            },
+          };
+          break;
+        }
+        case SendAuthorization.typeUrl: {
+          const spend = SendAuthorization.decode(grant.authorization.value);
+          authorizationValue = {
+            type: 'cosmos-sdk/SendAuthorization',
+            value: {
+              spend_limit: spend.spendLimit,
+            },
+          };
+          break;
+        }
+        default:
+          throw new Error(`Unsupported grant type: '${grant.authorization.typeUrl}'`);
         }
-        const expiration = grant.expiration?.seconds;
 
         return {
           granter,
@@ -47,8 +51,8 @@ export function createAuthzAminoConverters(): AminoConverters {
             authorization: authorizationValue,
             expiration: grant.expiration
               ? fromTimestamp(grant.expiration)
-                  .toISOString()
-                  .replace(/\.\d{3}Z$/, "Z")
+                .toISOString()
+                .replace(/\.\d{3}Z$/, 'Z')
               : undefined,
           },
         };
@@ -57,28 +61,28 @@ export function createAuthzAminoConverters(): AminoConverters {
         const authorizationType = grant?.authorization?.type;
         let authorizationValue;
         switch (authorizationType) {
-          case "cosmos-sdk/GenericAuthorization": {
-            authorizationValue = {
-              typeUrl: GenericAuthorization.typeUrl,
-              value: GenericAuthorization.encode({
-                msg: grant.authorization.value.msg,
-              }).finish(),
-            };
-            break;
-          }
-          case "cosmos-sdk/SendAuthorization": {
-            authorizationValue = {
-              typeUrl: SendAuthorization.typeUrl,
-              value: SendAuthorization.encode(
-                SendAuthorization.fromPartial({
-                  spendLimit: grant.authorization.value.spend_limit,
-                }),
-              ).finish(),
-            };
-            break;
-          }
-          default:
-            throw new Error(`Unsupported grant type: '${grant?.authorization?.type}'`);
+        case 'cosmos-sdk/GenericAuthorization': {
+          authorizationValue = {
+            typeUrl: GenericAuthorization.typeUrl,
+            value: GenericAuthorization.encode({
+              msg: grant.authorization.value.msg,
+            }).finish(),
+          };
+          break;
+        }
+        case 'cosmos-sdk/SendAuthorization': {
+          authorizationValue = {
+            typeUrl: SendAuthorization.typeUrl,
+            value: SendAuthorization.encode(
+              SendAuthorization.fromPartial({
+                spendLimit: grant.authorization.value.spend_limit,
+              }),
+            ).finish(),
+          };
+          break;
+        }
+        default:
+          throw new Error(`Unsupported grant type: '${grant?.authorization?.type}'`);
         }
         return MsgGrant.fromPartial({
           granter,
@@ -91,18 +95,19 @@ export function createAuthzAminoConverters(): AminoConverters {
       },
     },
     [MsgRevoke.typeUrl]: {
-      aminoType: "cosmos-sdk/MsgRevoke",
-      toAmino: ({ granter, grantee, msgTypeUrl }) => ({
+      aminoType: 'cosmos-sdk/MsgRevoke',
+      toAmino: ({ granter, grantee, msgTypeUrl }) => {
+        return {
+          granter,
+          grantee,
+          msg_type_url: msgTypeUrl,
+        };
+      },
+      fromAmino: ({ granter, grantee, msg_type_url }) => MsgRevoke.fromPartial({
         granter,
         grantee,
-        msg_type_url: msgTypeUrl,
+        msgTypeUrl: msg_type_url,
       }),
-      fromAmino: ({ granter, grantee, msg_type_url }) =>
-        MsgRevoke.fromPartial({
-          granter,
-          grantee,
-          msgTypeUrl: msg_type_url,
-        }),
     },
   };
-}
+};

packages/arch3-core/src/signingarchwayclient.ts

@@ -19,7 +19,7 @@ import {
   logs,
   StdFee,
 } from '@cosmjs/stargate';
-import { CometClient, HttpBatchClient, HttpBatchClientOptions, RpcClient, connectComet } from '@cosmjs/tendermint-rpc';
+import { CometClient, HttpBatchClient, HttpBatchClientOptions, connectComet } from '@cosmjs/tendermint-rpc';
 import { assertDefined } from '@cosmjs/utils';
 import { SimulateResponse } from 'cosmjs-types/cosmos/tx/v1beta1/service';
 import _ from 'lodash';