Merge pull request #1933 from cosmos/proto-signing-types

Add support for ts-proto version 2

Author: webmaster128

.pnp.cjs

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8fb0c728d64f4a31ee6063d605fd769a883d8e2bd9a4d7cc7790681016048642
+size 1655274

.yarn/cache/@bufbuild-protobuf-npm-2.10.2-590393a75c-970c4020bf.zip

@@ -24,7 +24,12 @@ and this project adheres to
 - @cosmjs/cosmwasm-stargate: Add the ability to specify a custom account parser
   for `CosmWasmClient`. ([#1928])
 - Add support for Cosmos EVM key handling and signing. ([#1932])
+- @cosmjs/proto-signing: Add support for ts-proto v2 through the newly added
+  `TsProto2GeneratedType` interface. As long as the existing
+  `TsProtoGeneratedType` is not removed, ts-proto v1 remains supported.
+  ([#1613])
 
+[#1613]: https://github.com/cosmos/cosmjs/issues/1613
 [#1883]: https://github.com/cosmos/cosmjs/issues/1883
 [#1916]: https://github.com/cosmos/cosmjs/pull/1916
 [#1926]: https://github.com/cosmos/cosmjs/pull/1926
@@ -114,6 +119,13 @@ and this project adheres to
   through strings in cases where you have a BitInt already. Strings remain
   supported for convenient usage with coins.
 - @cosmjs/math: `Decimal` now supports negative values. ([#1930])
+- @cosmjs/proto-signing: Remove `isTelescopeGeneratedType`,
+  `isTsProtoGeneratedType` and `isPbjsGeneratedType` because they are
+  unreliable. E.g. the `typeUrl` in Telescope may or may not exist depending on
+  the configuration. The newly added `hasFromPartial`/`hasCreate` allow you to
+  check for `TelescopeGeneratedType | TsProtoGeneratedType`/`PbjsGeneratedType`
+  such that you can create instanes through
+  `MyMessage.fromPartial()`/`MyMessage.create()`.
 
 [#1883]: https://github.com/cosmos/cosmjs/issues/1883
 [#1866]: https://github.com/cosmos/cosmjs/issues/1866

CHANGELOG.md

@@ -49,6 +49,7 @@
     "cosmjs-types": "^0.11.0"
   },
   "devDependencies": {
+    "@bufbuild/protobuf": "^2.10.2",
     "@istanbuljs/nyc-config-typescript": "^1.0.1",
     "@types/jasmine": "^4",
     "@types/karma-firefox-launcher": "^2",

packages/proto-signing/package.json

@@ -16,10 +16,11 @@ export type {
   EncodeObject,
   GeneratedType,
   PbjsGeneratedType,
+  TsProto2GeneratedType,
   TsProtoGeneratedType,
   TxBodyEncodeObject,
 } from "./registry";
-export { isPbjsGeneratedType, isTsProtoGeneratedType, isTxBodyEncodeObject, Registry } from "./registry";
+export { hasCreate, hasFromPartial, isTxBodyEncodeObject, Registry } from "./registry";
 export type { AccountData, Algo, DirectSignResponse, OfflineDirectSigner, OfflineSigner } from "./signer";
 export { isOfflineDirectSigner } from "./signer";
 export { makeAuthInfoBytes, makeSignBytes, makeSignDoc } from "./signing";

packages/proto-signing/src/index.ts

@@ -6,17 +6,47 @@ import { TxBody } from "cosmjs-types/cosmos/tx/v1beta1/tx";
 import { Any } from "cosmjs-types/google/protobuf/any";
 import { Field, Type } from "protobufjs";
 
-import { isPbjsGeneratedType, isTsProtoGeneratedType, Registry } from "./registry";
+import {
+  hasCreate,
+  hasFromPartial,
+  Registry,
+  TelescopeGeneratedType,
+  TsProto2GeneratedType,
+  TsProtoGeneratedType,
+} from "./registry";
+import * as tsProto1 from "./testdata/ts-proto-v1";
+import * as tsProto2 from "./testdata/ts-proto-v2";
 
 describe("registry demo", () => {
+  describe("TelescopeGeneratedType", () => {
+    it("is compatible with cosmjs-types generated types", () => {
+      const t: TelescopeGeneratedType = TxBody;
+      expect(typeof t.fromPartial).toEqual("function");
+    });
+  });
+
+  describe("TsProtoGeneratedType", () => {
+    it("is compatible with ts-proto v1 generated types", () => {
+      const t: TsProtoGeneratedType = tsProto1.Record;
+      expect(typeof t.fromPartial).toEqual("function");
+    });
+  });
+
+  describe("TsProto2GeneratedType", () => {
+    it("is compatible with ts-proto v2 generated types", () => {
+      const t: TsProto2GeneratedType = tsProto2.Record;
+      expect(typeof t.fromPartial).toEqual("function");
+    });
+  });
+
   it("works with a default msg", () => {
     const registry = new Registry();
     const Coin = registry.lookupType("/cosmos.base.v1beta1.Coin");
     const MsgSend = registry.lookupType("/cosmos.bank.v1beta1.MsgSend");
     assert(Coin);
     assert(MsgSend);
-    assert(isTsProtoGeneratedType(Coin));
-    assert(isTsProtoGeneratedType(MsgSend));
+    assert(hasFromPartial(Coin));
+    assert(hasFromPartial(MsgSend));
 
     const coin = Coin.fromPartial({
       denom: "ucosm",
@@ -67,7 +97,7 @@ describe("registry demo", () => {
     registry.register(typeUrl, MsgCreatePostOriginal);
     const MsgCreatePost = registry.lookupType(typeUrl);
     assert(MsgCreatePost);
-    assert(isPbjsGeneratedType(MsgCreatePost));
+    assert(hasCreate(MsgCreatePost));
 
     const msgDemo = MsgCreatePost.create({
       creator: "Me",

packages/proto-signing/src/registry.spec.ts

@@ -1,3 +1,4 @@
+import type * as bbw from "@bufbuild/protobuf/wire";
 import { fixUint8Array } from "@cosmjs/encoding";
 import { BinaryWriter } from "cosmjs-types/binary";
 import { MsgSend } from "cosmjs-types/cosmos/bank/v1beta1/tx";
@@ -25,7 +26,7 @@ export interface TelescopeGeneratedType {
 }
 
 /**
- * A type generated by [ts-proto](https://github.com/stephenh/ts-proto).
+ * A type generated by [ts-proto](https://github.com/stephenh/ts-proto) version 1.
  */
 export interface TsProtoGeneratedType {
   readonly encode: (message: any | { [k: string]: any }, writer?: protobuf.Writer) => protobuf.Writer;
@@ -34,6 +35,29 @@ export interface TsProtoGeneratedType {
   // Methods from ts-proto types we don't need
   // readonly fromJSON: (object: any) => any;
   // readonly toJSON: (message: any | { [k: string]: any }) => unknown;
+
+  // This was added at some point in 2023 and looks pretty compatible to the PbjsGeneratedType constructor.
+  // but we don't need it as long as Telescope does not have it. `fromPartial` is widespread and works well.
+  // See https://github.com/stephenh/ts-proto/pull/760
+  // readonly create: (object?: any) => any;
+}
+
+/**
+ * A type generated by [ts-proto](https://github.com/stephenh/ts-proto) version 2.
+ * See "ts-proto 2.x Release Notes" at https://github.com/stephenh/ts-proto/blob/v2.10.0/README.markdown#ts-proto-2x-release-notes
+ */
+export interface TsProto2GeneratedType {
+  readonly encode: (message: any | { [k: string]: any }, writer?: bbw.BinaryWriter) => bbw.BinaryWriter;
+  readonly decode: (input: Uint8Array | bbw.BinaryReader, length?: number) => any;
+  readonly fromPartial: (object: any) => any;
+  // Methods from ts-proto types we don't need
+  // readonly fromJSON: (object: any) => any;
+  // readonly toJSON: (message: any | { [k: string]: any }) => unknown;
+
+  // This was added at some point in 2023 and looks pretty compatible to the PbjsGeneratedType constructor.
+  // but we don't need it as long as Telescope does not have it. `fromPartial` is widespread and works well.
+  // See https://github.com/stephenh/ts-proto/pull/760
+  // readonly create: (object?: any) => any;
 }
 
 /**
@@ -48,19 +72,23 @@ export interface PbjsGeneratedType {
   readonly decode: (reader: protobuf.Reader | Uint8Array, length?: number) => any;
 }
 
-export type GeneratedType = TelescopeGeneratedType | TsProtoGeneratedType | PbjsGeneratedType;
-
-export function isTelescopeGeneratedType(type: GeneratedType): type is TelescopeGeneratedType {
-  const casted = type as TelescopeGeneratedType;
-  return typeof casted.fromPartial === "function" && typeof casted.typeUrl == "string";
-}
-
-export function isTsProtoGeneratedType(type: GeneratedType): type is TsProtoGeneratedType {
-  return typeof (type as TsProtoGeneratedType).fromPartial === "function";
+export type GeneratedType =
+  | TelescopeGeneratedType
+  | TsProtoGeneratedType
+  | TsProto2GeneratedType
+  | PbjsGeneratedType;
+
+export function hasFromPartial(
+  type: GeneratedType,
+): type is TelescopeGeneratedType | TsProtoGeneratedType | TsProto2GeneratedType {
+  return (
+    typeof (type as TelescopeGeneratedType | TsProtoGeneratedType | TsProto2GeneratedType).fromPartial ===
+    "function"
+  );
 }
 
-export function isPbjsGeneratedType(type: GeneratedType): type is PbjsGeneratedType {
-  return !isTsProtoGeneratedType(type);
+export function hasCreate(type: GeneratedType): type is PbjsGeneratedType {
+  return typeof (type as PbjsGeneratedType).create === "function";
 }
 
 const defaultTypeUrls = {
@@ -137,7 +165,7 @@ export class Registry {
    *
    * const Coin = registry.lookupType("/cosmos.base.v1beta1.Coin");
    * assert(Coin); // Ensures not unset
-   * assert(isTsProtoGeneratedType(Coin)); // Ensures this is the type we expect
+   * assert(hasFromPartial(Coin)); // Ensures this is the type we expect
    *
    * // Coin is typed TsProtoGeneratedType now.
    * ```
@@ -167,10 +195,7 @@ export class Registry {
       return this.encodeTxBody(value);
     }
     const type = this.lookupTypeWithError(typeUrl);
-    const instance =
-      isTelescopeGeneratedType(type) || isTsProtoGeneratedType(type)
-        ? type.fromPartial(value)
-        : type.create(value);
+    const instance = hasFromPartial(type) ? type.fromPartial(value) : type.create(value);
     return fixUint8Array(type.encode(instance).finish());
   }
 

packages/proto-signing/src/registry.ts

@@ -0,0 +1,71 @@
+// from https://github.com/stephenh/ts-proto/blob/v1.181.2/integration/reserved-words/reserved-words.ts
+
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// source: reserved-words.proto
+
+/* eslint-disable */
+import * as _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "";
+
+export interface Record {}
+
+function createBaseRecord(): Record {
+  return {};
+}
+
+export const Record = {
+  encode(_: Record, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Record {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRecord();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): Record {
+    return {};
+  },
+
+  toJSON(_: Record): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Record>, I>>(base?: I): Record {
+    return Record.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Record>, I>>(_: I): Record {
+    const message = createBaseRecord();
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin
+  ? T
+  : T extends globalThis.Array<infer U>
+    ? globalThis.Array<DeepPartial<U>>
+    : T extends ReadonlyArray<infer U>
+      ? ReadonlyArray<DeepPartial<U>>
+      : T extends {}
+        ? { [K in keyof T]?: DeepPartial<T[K]> }
+        : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin
+  ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };

packages/proto-signing/src/testdata/ts-proto-v1.ts

@@ -0,0 +1,80 @@
+// from https://github.com/stephenh/ts-proto/blob/v2.10.0/integration/reserved-words/reserved-words.ts
+
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// source: reserved-words.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+
+export const protobufPackage = "";
+
+export interface Record {}
+
+function createBaseRecord(): Record {
+  return {};
+}
+
+export const Record: MessageFns<Record> = {
+  encode(_: Record, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Record {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRecord();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): Record {
+    return {};
+  },
+
+  toJSON(_: Record): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Record>, I>>(base?: I): Record {
+    return Record.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Record>, I>>(_: I): Record {
+    const message = createBaseRecord();
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin
+  ? T
+  : T extends globalThis.Array<infer U>
+    ? globalThis.Array<DeepPartial<U>>
+    : T extends ReadonlyArray<infer U>
+      ? ReadonlyArray<DeepPartial<U>>
+      : T extends {}
+        ? { [K in keyof T]?: DeepPartial<T[K]> }
+        : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin
+  ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}