juno-network 0.15.0 → 0.17.0

package/src/codegen/cosmos/capability/v1beta1/capability.ts

@@ -0,0 +1,312 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/**
+ * Capability defines an implementation of an object capability. The index
+ * provided to a Capability must be globally unique.
+ */
+export interface Capability {
+  index: bigint;
+}
+export interface CapabilityProtoMsg {
+  typeUrl: "/cosmos.capability.v1beta1.Capability";
+  value: Uint8Array;
+}
+/**
+ * Capability defines an implementation of an object capability. The index
+ * provided to a Capability must be globally unique.
+ */
+export interface CapabilityAmino {
+  index?: string;
+}
+export interface CapabilityAminoMsg {
+  type: "cosmos-sdk/Capability";
+  value: CapabilityAmino;
+}
+/**
+ * Capability defines an implementation of an object capability. The index
+ * provided to a Capability must be globally unique.
+ */
+export interface CapabilitySDKType {
+  index: bigint;
+}
+/**
+ * Owner defines a single capability owner. An owner is defined by the name of
+ * capability and the module name.
+ */
+export interface Owner {
+  module: string;
+  name: string;
+}
+export interface OwnerProtoMsg {
+  typeUrl: "/cosmos.capability.v1beta1.Owner";
+  value: Uint8Array;
+}
+/**
+ * Owner defines a single capability owner. An owner is defined by the name of
+ * capability and the module name.
+ */
+export interface OwnerAmino {
+  module?: string;
+  name?: string;
+}
+export interface OwnerAminoMsg {
+  type: "cosmos-sdk/Owner";
+  value: OwnerAmino;
+}
+/**
+ * Owner defines a single capability owner. An owner is defined by the name of
+ * capability and the module name.
+ */
+export interface OwnerSDKType {
+  module: string;
+  name: string;
+}
+/**
+ * CapabilityOwners defines a set of owners of a single Capability. The set of
+ * owners must be unique.
+ */
+export interface CapabilityOwners {
+  owners: Owner[];
+}
+export interface CapabilityOwnersProtoMsg {
+  typeUrl: "/cosmos.capability.v1beta1.CapabilityOwners";
+  value: Uint8Array;
+}
+/**
+ * CapabilityOwners defines a set of owners of a single Capability. The set of
+ * owners must be unique.
+ */
+export interface CapabilityOwnersAmino {
+  owners?: OwnerAmino[];
+}
+export interface CapabilityOwnersAminoMsg {
+  type: "cosmos-sdk/CapabilityOwners";
+  value: CapabilityOwnersAmino;
+}
+/**
+ * CapabilityOwners defines a set of owners of a single Capability. The set of
+ * owners must be unique.
+ */
+export interface CapabilityOwnersSDKType {
+  owners: OwnerSDKType[];
+}
+function createBaseCapability(): Capability {
+  return {
+    index: BigInt(0)
+  };
+}
+export const Capability = {
+  typeUrl: "/cosmos.capability.v1beta1.Capability",
+  encode(message: Capability, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.index !== BigInt(0)) {
+      writer.uint32(8).uint64(message.index);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Capability {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCapability();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.index = reader.uint64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Capability>): Capability {
+    const message = createBaseCapability();
+    message.index = object.index !== undefined && object.index !== null ? BigInt(object.index.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: CapabilityAmino): Capability {
+    const message = createBaseCapability();
+    if (object.index !== undefined && object.index !== null) {
+      message.index = BigInt(object.index);
+    }
+    return message;
+  },
+  toAmino(message: Capability): CapabilityAmino {
+    const obj: any = {};
+    obj.index = message.index ? message.index.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: CapabilityAminoMsg): Capability {
+    return Capability.fromAmino(object.value);
+  },
+  toAminoMsg(message: Capability): CapabilityAminoMsg {
+    return {
+      type: "cosmos-sdk/Capability",
+      value: Capability.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: CapabilityProtoMsg): Capability {
+    return Capability.decode(message.value);
+  },
+  toProto(message: Capability): Uint8Array {
+    return Capability.encode(message).finish();
+  },
+  toProtoMsg(message: Capability): CapabilityProtoMsg {
+    return {
+      typeUrl: "/cosmos.capability.v1beta1.Capability",
+      value: Capability.encode(message).finish()
+    };
+  }
+};
+function createBaseOwner(): Owner {
+  return {
+    module: "",
+    name: ""
+  };
+}
+export const Owner = {
+  typeUrl: "/cosmos.capability.v1beta1.Owner",
+  encode(message: Owner, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.module !== "") {
+      writer.uint32(10).string(message.module);
+    }
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Owner {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseOwner();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.module = reader.string();
+          break;
+        case 2:
+          message.name = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Owner>): Owner {
+    const message = createBaseOwner();
+    message.module = object.module ?? "";
+    message.name = object.name ?? "";
+    return message;
+  },
+  fromAmino(object: OwnerAmino): Owner {
+    const message = createBaseOwner();
+    if (object.module !== undefined && object.module !== null) {
+      message.module = object.module;
+    }
+    if (object.name !== undefined && object.name !== null) {
+      message.name = object.name;
+    }
+    return message;
+  },
+  toAmino(message: Owner): OwnerAmino {
+    const obj: any = {};
+    obj.module = message.module;
+    obj.name = message.name;
+    return obj;
+  },
+  fromAminoMsg(object: OwnerAminoMsg): Owner {
+    return Owner.fromAmino(object.value);
+  },
+  toAminoMsg(message: Owner): OwnerAminoMsg {
+    return {
+      type: "cosmos-sdk/Owner",
+      value: Owner.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: OwnerProtoMsg): Owner {
+    return Owner.decode(message.value);
+  },
+  toProto(message: Owner): Uint8Array {
+    return Owner.encode(message).finish();
+  },
+  toProtoMsg(message: Owner): OwnerProtoMsg {
+    return {
+      typeUrl: "/cosmos.capability.v1beta1.Owner",
+      value: Owner.encode(message).finish()
+    };
+  }
+};
+function createBaseCapabilityOwners(): CapabilityOwners {
+  return {
+    owners: []
+  };
+}
+export const CapabilityOwners = {
+  typeUrl: "/cosmos.capability.v1beta1.CapabilityOwners",
+  encode(message: CapabilityOwners, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.owners) {
+      Owner.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): CapabilityOwners {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCapabilityOwners();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.owners.push(Owner.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<CapabilityOwners>): CapabilityOwners {
+    const message = createBaseCapabilityOwners();
+    message.owners = object.owners?.map(e => Owner.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: CapabilityOwnersAmino): CapabilityOwners {
+    const message = createBaseCapabilityOwners();
+    message.owners = object.owners?.map(e => Owner.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: CapabilityOwners): CapabilityOwnersAmino {
+    const obj: any = {};
+    if (message.owners) {
+      obj.owners = message.owners.map(e => e ? Owner.toAmino(e) : undefined);
+    } else {
+      obj.owners = [];
+    }
+    return obj;
+  },
+  fromAminoMsg(object: CapabilityOwnersAminoMsg): CapabilityOwners {
+    return CapabilityOwners.fromAmino(object.value);
+  },
+  toAminoMsg(message: CapabilityOwners): CapabilityOwnersAminoMsg {
+    return {
+      type: "cosmos-sdk/CapabilityOwners",
+      value: CapabilityOwners.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: CapabilityOwnersProtoMsg): CapabilityOwners {
+    return CapabilityOwners.decode(message.value);
+  },
+  toProto(message: CapabilityOwners): Uint8Array {
+    return CapabilityOwners.encode(message).finish();
+  },
+  toProtoMsg(message: CapabilityOwners): CapabilityOwnersProtoMsg {
+    return {
+      typeUrl: "/cosmos.capability.v1beta1.CapabilityOwners",
+      value: CapabilityOwners.encode(message).finish()
+    };
+  }
+};

package/src/codegen/cosmos/capability/v1beta1/genesis.ts

@@ -0,0 +1,226 @@
+import { CapabilityOwners, CapabilityOwnersAmino, CapabilityOwnersSDKType } from "./capability";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** GenesisOwners defines the capability owners with their corresponding index. */
+export interface GenesisOwners {
+  /** index is the index of the capability owner. */
+  index: bigint;
+  /** index_owners are the owners at the given index. */
+  indexOwners: CapabilityOwners;
+}
+export interface GenesisOwnersProtoMsg {
+  typeUrl: "/cosmos.capability.v1beta1.GenesisOwners";
+  value: Uint8Array;
+}
+/** GenesisOwners defines the capability owners with their corresponding index. */
+export interface GenesisOwnersAmino {
+  /** index is the index of the capability owner. */
+  index?: string;
+  /** index_owners are the owners at the given index. */
+  index_owners?: CapabilityOwnersAmino;
+}
+export interface GenesisOwnersAminoMsg {
+  type: "cosmos-sdk/GenesisOwners";
+  value: GenesisOwnersAmino;
+}
+/** GenesisOwners defines the capability owners with their corresponding index. */
+export interface GenesisOwnersSDKType {
+  index: bigint;
+  index_owners: CapabilityOwnersSDKType;
+}
+/** GenesisState defines the capability module's genesis state. */
+export interface GenesisState {
+  /** index is the capability global index. */
+  index: bigint;
+  /**
+   * owners represents a map from index to owners of the capability index
+   * index key is string to allow amino marshalling.
+   */
+  owners: GenesisOwners[];
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/cosmos.capability.v1beta1.GenesisState";
+  value: Uint8Array;
+}
+/** GenesisState defines the capability module's genesis state. */
+export interface GenesisStateAmino {
+  /** index is the capability global index. */
+  index?: string;
+  /**
+   * owners represents a map from index to owners of the capability index
+   * index key is string to allow amino marshalling.
+   */
+  owners?: GenesisOwnersAmino[];
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+/** GenesisState defines the capability module's genesis state. */
+export interface GenesisStateSDKType {
+  index: bigint;
+  owners: GenesisOwnersSDKType[];
+}
+function createBaseGenesisOwners(): GenesisOwners {
+  return {
+    index: BigInt(0),
+    indexOwners: CapabilityOwners.fromPartial({})
+  };
+}
+export const GenesisOwners = {
+  typeUrl: "/cosmos.capability.v1beta1.GenesisOwners",
+  encode(message: GenesisOwners, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.index !== BigInt(0)) {
+      writer.uint32(8).uint64(message.index);
+    }
+    if (message.indexOwners !== undefined) {
+      CapabilityOwners.encode(message.indexOwners, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): GenesisOwners {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisOwners();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.index = reader.uint64();
+          break;
+        case 2:
+          message.indexOwners = CapabilityOwners.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GenesisOwners>): GenesisOwners {
+    const message = createBaseGenesisOwners();
+    message.index = object.index !== undefined && object.index !== null ? BigInt(object.index.toString()) : BigInt(0);
+    message.indexOwners = object.indexOwners !== undefined && object.indexOwners !== null ? CapabilityOwners.fromPartial(object.indexOwners) : undefined;
+    return message;
+  },
+  fromAmino(object: GenesisOwnersAmino): GenesisOwners {
+    const message = createBaseGenesisOwners();
+    if (object.index !== undefined && object.index !== null) {
+      message.index = BigInt(object.index);
+    }
+    if (object.index_owners !== undefined && object.index_owners !== null) {
+      message.indexOwners = CapabilityOwners.fromAmino(object.index_owners);
+    }
+    return message;
+  },
+  toAmino(message: GenesisOwners): GenesisOwnersAmino {
+    const obj: any = {};
+    obj.index = message.index ? message.index.toString() : undefined;
+    obj.index_owners = message.indexOwners ? CapabilityOwners.toAmino(message.indexOwners) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: GenesisOwnersAminoMsg): GenesisOwners {
+    return GenesisOwners.fromAmino(object.value);
+  },
+  toAminoMsg(message: GenesisOwners): GenesisOwnersAminoMsg {
+    return {
+      type: "cosmos-sdk/GenesisOwners",
+      value: GenesisOwners.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: GenesisOwnersProtoMsg): GenesisOwners {
+    return GenesisOwners.decode(message.value);
+  },
+  toProto(message: GenesisOwners): Uint8Array {
+    return GenesisOwners.encode(message).finish();
+  },
+  toProtoMsg(message: GenesisOwners): GenesisOwnersProtoMsg {
+    return {
+      typeUrl: "/cosmos.capability.v1beta1.GenesisOwners",
+      value: GenesisOwners.encode(message).finish()
+    };
+  }
+};
+function createBaseGenesisState(): GenesisState {
+  return {
+    index: BigInt(0),
+    owners: []
+  };
+}
+export const GenesisState = {
+  typeUrl: "/cosmos.capability.v1beta1.GenesisState",
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.index !== BigInt(0)) {
+      writer.uint32(8).uint64(message.index);
+    }
+    for (const v of message.owners) {
+      GenesisOwners.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): GenesisState {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisState();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.index = reader.uint64();
+          break;
+        case 2:
+          message.owners.push(GenesisOwners.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.index = object.index !== undefined && object.index !== null ? BigInt(object.index.toString()) : BigInt(0);
+    message.owners = object.owners?.map(e => GenesisOwners.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    if (object.index !== undefined && object.index !== null) {
+      message.index = BigInt(object.index);
+    }
+    message.owners = object.owners?.map(e => GenesisOwners.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    obj.index = message.index ? message.index.toString() : undefined;
+    if (message.owners) {
+      obj.owners = message.owners.map(e => e ? GenesisOwners.toAmino(e) : undefined);
+    } else {
+      obj.owners = [];
+    }
+    return obj;
+  },
+  fromAminoMsg(object: GenesisStateAminoMsg): GenesisState {
+    return GenesisState.fromAmino(object.value);
+  },
+  toAminoMsg(message: GenesisState): GenesisStateAminoMsg {
+    return {
+      type: "cosmos-sdk/GenesisState",
+      value: GenesisState.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: GenesisStateProtoMsg): GenesisState {
+    return GenesisState.decode(message.value);
+  },
+  toProto(message: GenesisState): Uint8Array {
+    return GenesisState.encode(message).finish();
+  },
+  toProtoMsg(message: GenesisState): GenesisStateProtoMsg {
+    return {
+      typeUrl: "/cosmos.capability.v1beta1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};

package/src/codegen/cosmos/client.ts

@@ -1,32 +1,58 @@
 import { GeneratedType, Registry, OfflineSigner } from "@cosmjs/proto-signing";
 import { AminoTypes, SigningStargateClient } from "@cosmjs/stargate";
 import { HttpEndpoint } from "@cosmjs/tendermint-rpc";
+import * as cosmosAuthzV1beta1TxRegistry from "./authz/v1beta1/tx.registry";
 import * as cosmosBankV1beta1TxRegistry from "./bank/v1beta1/tx.registry";
+import * as cosmosCrisisV1beta1TxRegistry from "./crisis/v1beta1/tx.registry";
 import * as cosmosDistributionV1beta1TxRegistry from "./distribution/v1beta1/tx.registry";
+import * as cosmosEvidenceV1beta1TxRegistry from "./evidence/v1beta1/tx.registry";
+import * as cosmosFeegrantV1beta1TxRegistry from "./feegrant/v1beta1/tx.registry";
 import * as cosmosGovV1TxRegistry from "./gov/v1/tx.registry";
 import * as cosmosGovV1beta1TxRegistry from "./gov/v1beta1/tx.registry";
+import * as cosmosGroupV1TxRegistry from "./group/v1/tx.registry";
+import * as cosmosNftV1beta1TxRegistry from "./nft/v1beta1/tx.registry";
+import * as cosmosSlashingV1beta1TxRegistry from "./slashing/v1beta1/tx.registry";
 import * as cosmosStakingV1beta1TxRegistry from "./staking/v1beta1/tx.registry";
 import * as cosmosUpgradeV1beta1TxRegistry from "./upgrade/v1beta1/tx.registry";
+import * as cosmosVestingV1beta1TxRegistry from "./vesting/v1beta1/tx.registry";
+import * as cosmosAuthzV1beta1TxAmino from "./authz/v1beta1/tx.amino";
 import * as cosmosBankV1beta1TxAmino from "./bank/v1beta1/tx.amino";
+import * as cosmosCrisisV1beta1TxAmino from "./crisis/v1beta1/tx.amino";
 import * as cosmosDistributionV1beta1TxAmino from "./distribution/v1beta1/tx.amino";
+import * as cosmosEvidenceV1beta1TxAmino from "./evidence/v1beta1/tx.amino";
+import * as cosmosFeegrantV1beta1TxAmino from "./feegrant/v1beta1/tx.amino";
 import * as cosmosGovV1TxAmino from "./gov/v1/tx.amino";
 import * as cosmosGovV1beta1TxAmino from "./gov/v1beta1/tx.amino";
+import * as cosmosGroupV1TxAmino from "./group/v1/tx.amino";
+import * as cosmosNftV1beta1TxAmino from "./nft/v1beta1/tx.amino";
+import * as cosmosSlashingV1beta1TxAmino from "./slashing/v1beta1/tx.amino";
 import * as cosmosStakingV1beta1TxAmino from "./staking/v1beta1/tx.amino";
 import * as cosmosUpgradeV1beta1TxAmino from "./upgrade/v1beta1/tx.amino";
-export const cosmosAminoConverters = { ...cosmosBankV1beta1TxAmino.AminoConverter,
+import * as cosmosVestingV1beta1TxAmino from "./vesting/v1beta1/tx.amino";
+export const cosmosAminoConverters = {
+  ...cosmosAuthzV1beta1TxAmino.AminoConverter,
+  ...cosmosBankV1beta1TxAmino.AminoConverter,
+  ...cosmosCrisisV1beta1TxAmino.AminoConverter,
   ...cosmosDistributionV1beta1TxAmino.AminoConverter,
+  ...cosmosEvidenceV1beta1TxAmino.AminoConverter,
+  ...cosmosFeegrantV1beta1TxAmino.AminoConverter,
   ...cosmosGovV1TxAmino.AminoConverter,
   ...cosmosGovV1beta1TxAmino.AminoConverter,
+  ...cosmosGroupV1TxAmino.AminoConverter,
+  ...cosmosNftV1beta1TxAmino.AminoConverter,
+  ...cosmosSlashingV1beta1TxAmino.AminoConverter,
   ...cosmosStakingV1beta1TxAmino.AminoConverter,
-  ...cosmosUpgradeV1beta1TxAmino.AminoConverter
+  ...cosmosUpgradeV1beta1TxAmino.AminoConverter,
+  ...cosmosVestingV1beta1TxAmino.AminoConverter
 };
-export const cosmosProtoRegistry: ReadonlyArray<[string, GeneratedType]> = [...cosmosBankV1beta1TxRegistry.registry, ...cosmosDistributionV1beta1TxRegistry.registry, ...cosmosGovV1TxRegistry.registry, ...cosmosGovV1beta1TxRegistry.registry, ...cosmosStakingV1beta1TxRegistry.registry, ...cosmosUpgradeV1beta1TxRegistry.registry];
+export const cosmosProtoRegistry: ReadonlyArray<[string, GeneratedType]> = [...cosmosAuthzV1beta1TxRegistry.registry, ...cosmosBankV1beta1TxRegistry.registry, ...cosmosCrisisV1beta1TxRegistry.registry, ...cosmosDistributionV1beta1TxRegistry.registry, ...cosmosEvidenceV1beta1TxRegistry.registry, ...cosmosFeegrantV1beta1TxRegistry.registry, ...cosmosGovV1TxRegistry.registry, ...cosmosGovV1beta1TxRegistry.registry, ...cosmosGroupV1TxRegistry.registry, ...cosmosNftV1beta1TxRegistry.registry, ...cosmosSlashingV1beta1TxRegistry.registry, ...cosmosStakingV1beta1TxRegistry.registry, ...cosmosUpgradeV1beta1TxRegistry.registry, ...cosmosVestingV1beta1TxRegistry.registry];
 export const getSigningCosmosClientOptions = (): {
   registry: Registry;
   aminoTypes: AminoTypes;
 } => {
   const registry = new Registry([...cosmosProtoRegistry]);
-  const aminoTypes = new AminoTypes({ ...cosmosAminoConverters
+  const aminoTypes = new AminoTypes({
+    ...cosmosAminoConverters
   });
   return {
     registry,
@@ -45,7 +71,7 @@ export const getSigningCosmosClient = async ({
     aminoTypes
   } = getSigningCosmosClientOptions();
   const client = await SigningStargateClient.connectWithSigner(rpcEndpoint, signer, {
-    registry,
+    registry: (registry as any),
     aminoTypes
   });
   return client;