@agoric/cosmic-proto 0.4.1-upgrade-16-dev-0df76a7.0 → 0.4.1-upgrade-17-dev-e67cd91.0

package/dist/codegen/icq/bundle.js

@@ -1,17 +1,17 @@
 //@ts-nocheck
-import * as _118 from './v1/genesis.js';
-import * as _119 from './v1/icq.js';
-import * as _120 from './v1/packet.js';
-import * as _121 from './v1/query.js';
-import * as _122 from './v1/tx.js';
+import * as _119 from './v1/genesis.js';
+import * as _120 from './v1/icq.js';
+import * as _121 from './v1/packet.js';
+import * as _122 from './v1/query.js';
+import * as _123 from './v1/tx.js';
 export var icq;
 (function (icq) {
     icq.v1 = {
-        ..._118,
         ..._119,
         ..._120,
         ..._121,
         ..._122,
+        ..._123,
     };
 })(icq || (icq = {}));
 //# sourceMappingURL=bundle.js.map

package/dist/codegen/ics23/bundle.d.ts

@@ -1,154 +1,154 @@
-import * as _123 from '../proofs.js';
+import * as _124 from '../proofs.js';
 export declare const ics23: {
-    hashOpFromJSON(object: any): _123.HashOp;
-    hashOpToJSON(object: _123.HashOp): string;
-    lengthOpFromJSON(object: any): _123.LengthOp;
-    lengthOpToJSON(object: _123.LengthOp): string;
-    HashOp: typeof _123.HashOp;
-    HashOpSDKType: typeof _123.HashOp;
-    LengthOp: typeof _123.LengthOp;
-    LengthOpSDKType: typeof _123.LengthOp;
+    hashOpFromJSON(object: any): _124.HashOp;
+    hashOpToJSON(object: _124.HashOp): string;
+    lengthOpFromJSON(object: any): _124.LengthOp;
+    lengthOpToJSON(object: _124.LengthOp): string;
+    HashOp: typeof _124.HashOp;
+    HashOpSDKType: typeof _124.HashOp;
+    LengthOp: typeof _124.LengthOp;
+    LengthOpSDKType: typeof _124.LengthOp;
     ExistenceProof: {
         typeUrl: string;
-        encode(message: _123.ExistenceProof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _123.ExistenceProof;
-        fromJSON(object: any): _123.ExistenceProof;
-        toJSON(message: _123.ExistenceProof): import("../json-safe.js").JsonSafe<_123.ExistenceProof>;
-        fromPartial(object: Partial<_123.ExistenceProof>): _123.ExistenceProof;
-        fromProtoMsg(message: _123.ExistenceProofProtoMsg): _123.ExistenceProof;
-        toProto(message: _123.ExistenceProof): Uint8Array;
-        toProtoMsg(message: _123.ExistenceProof): _123.ExistenceProofProtoMsg;
+        encode(message: _124.ExistenceProof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ExistenceProof;
+        fromJSON(object: any): _124.ExistenceProof;
+        toJSON(message: _124.ExistenceProof): import("../json-safe.js").JsonSafe<_124.ExistenceProof>;
+        fromPartial(object: Partial<_124.ExistenceProof>): _124.ExistenceProof;
+        fromProtoMsg(message: _124.ExistenceProofProtoMsg): _124.ExistenceProof;
+        toProto(message: _124.ExistenceProof): Uint8Array;
+        toProtoMsg(message: _124.ExistenceProof): _124.ExistenceProofProtoMsg;
     };
     NonExistenceProof: {
         typeUrl: string;
-        encode(message: _123.NonExistenceProof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _123.NonExistenceProof;
-        fromJSON(object: any): _123.NonExistenceProof;
-        toJSON(message: _123.NonExistenceProof): import("../json-safe.js").JsonSafe<_123.NonExistenceProof>;
-        fromPartial(object: Partial<_123.NonExistenceProof>): _123.NonExistenceProof;
-        fromProtoMsg(message: _123.NonExistenceProofProtoMsg): _123.NonExistenceProof;
-        toProto(message: _123.NonExistenceProof): Uint8Array;
-        toProtoMsg(message: _123.NonExistenceProof): _123.NonExistenceProofProtoMsg;
+        encode(message: _124.NonExistenceProof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.NonExistenceProof;
+        fromJSON(object: any): _124.NonExistenceProof;
+        toJSON(message: _124.NonExistenceProof): import("../json-safe.js").JsonSafe<_124.NonExistenceProof>;
+        fromPartial(object: Partial<_124.NonExistenceProof>): _124.NonExistenceProof;
+        fromProtoMsg(message: _124.NonExistenceProofProtoMsg): _124.NonExistenceProof;
+        toProto(message: _124.NonExistenceProof): Uint8Array;
+        toProtoMsg(message: _124.NonExistenceProof): _124.NonExistenceProofProtoMsg;
     };
     CommitmentProof: {
         typeUrl: string;
-        encode(message: _123.CommitmentProof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _123.CommitmentProof;
-        fromJSON(object: any): _123.CommitmentProof;
-        toJSON(message: _123.CommitmentProof): import("../json-safe.js").JsonSafe<_123.CommitmentProof>;
-        fromPartial(object: Partial<_123.CommitmentProof>): _123.CommitmentProof;
-        fromProtoMsg(message: _123.CommitmentProofProtoMsg): _123.CommitmentProof;
-        toProto(message: _123.CommitmentProof): Uint8Array;
-        toProtoMsg(message: _123.CommitmentProof): _123.CommitmentProofProtoMsg;
+        encode(message: _124.CommitmentProof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.CommitmentProof;
+        fromJSON(object: any): _124.CommitmentProof;
+        toJSON(message: _124.CommitmentProof): import("../json-safe.js").JsonSafe<_124.CommitmentProof>;
+        fromPartial(object: Partial<_124.CommitmentProof>): _124.CommitmentProof;
+        fromProtoMsg(message: _124.CommitmentProofProtoMsg): _124.CommitmentProof;
+        toProto(message: _124.CommitmentProof): Uint8Array;
+        toProtoMsg(message: _124.CommitmentProof): _124.CommitmentProofProtoMsg;
     };
     LeafOp: {
         typeUrl: string;
-        encode(message: _123.LeafOp, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _123.LeafOp;
-        fromJSON(object: any): _123.LeafOp;
-        toJSON(message: _123.LeafOp): import("../json-safe.js").JsonSafe<_123.LeafOp>;
-        fromPartial(object: Partial<_123.LeafOp>): _123.LeafOp;
-        fromProtoMsg(message: _123.LeafOpProtoMsg): _123.LeafOp;
-        toProto(message: _123.LeafOp): Uint8Array;
-        toProtoMsg(message: _123.LeafOp): _123.LeafOpProtoMsg;
+        encode(message: _124.LeafOp, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.LeafOp;
+        fromJSON(object: any): _124.LeafOp;
+        toJSON(message: _124.LeafOp): import("../json-safe.js").JsonSafe<_124.LeafOp>;
+        fromPartial(object: Partial<_124.LeafOp>): _124.LeafOp;
+        fromProtoMsg(message: _124.LeafOpProtoMsg): _124.LeafOp;
+        toProto(message: _124.LeafOp): Uint8Array;
+        toProtoMsg(message: _124.LeafOp): _124.LeafOpProtoMsg;
     };
     InnerOp: {
         typeUrl: string;
-        encode(message: _123.InnerOp, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _123.InnerOp;
-        fromJSON(object: any): _123.InnerOp;
-        toJSON(message: _123.InnerOp): import("../json-safe.js").JsonSafe<_123.InnerOp>;
-        fromPartial(object: Partial<_123.InnerOp>): _123.InnerOp;
-        fromProtoMsg(message: _123.InnerOpProtoMsg): _123.InnerOp;
-        toProto(message: _123.InnerOp): Uint8Array;
-        toProtoMsg(message: _123.InnerOp): _123.InnerOpProtoMsg;
+        encode(message: _124.InnerOp, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.InnerOp;
+        fromJSON(object: any): _124.InnerOp;
+        toJSON(message: _124.InnerOp): import("../json-safe.js").JsonSafe<_124.InnerOp>;
+        fromPartial(object: Partial<_124.InnerOp>): _124.InnerOp;
+        fromProtoMsg(message: _124.InnerOpProtoMsg): _124.InnerOp;
+        toProto(message: _124.InnerOp): Uint8Array;
+        toProtoMsg(message: _124.InnerOp): _124.InnerOpProtoMsg;
     };
     ProofSpec: {
         typeUrl: string;
-        encode(message: _123.ProofSpec, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _123.ProofSpec;
-        fromJSON(object: any): _123.ProofSpec;
-        toJSON(message: _123.ProofSpec): import("../json-safe.js").JsonSafe<_123.ProofSpec>;
-        fromPartial(object: Partial<_123.ProofSpec>): _123.ProofSpec;
-        fromProtoMsg(message: _123.ProofSpecProtoMsg): _123.ProofSpec;
-        toProto(message: _123.ProofSpec): Uint8Array;
-        toProtoMsg(message: _123.ProofSpec): _123.ProofSpecProtoMsg;
+        encode(message: _124.ProofSpec, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ProofSpec;
+        fromJSON(object: any): _124.ProofSpec;
+        toJSON(message: _124.ProofSpec): import("../json-safe.js").JsonSafe<_124.ProofSpec>;
+        fromPartial(object: Partial<_124.ProofSpec>): _124.ProofSpec;
+        fromProtoMsg(message: _124.ProofSpecProtoMsg): _124.ProofSpec;
+        toProto(message: _124.ProofSpec): Uint8Array;
+        toProtoMsg(message: _124.ProofSpec): _124.ProofSpecProtoMsg;
     };
     InnerSpec: {
         typeUrl: string;
-        encode(message: _123.InnerSpec, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _123.InnerSpec;
-        fromJSON(object: any): _123.InnerSpec;
-        toJSON(message: _123.InnerSpec): import("../json-safe.js").JsonSafe<_123.InnerSpec>;
-        fromPartial(object: Partial<_123.InnerSpec>): _123.InnerSpec;
-        fromProtoMsg(message: _123.InnerSpecProtoMsg): _123.InnerSpec;
-        toProto(message: _123.InnerSpec): Uint8Array;
-        toProtoMsg(message: _123.InnerSpec): _123.InnerSpecProtoMsg;
+        encode(message: _124.InnerSpec, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.InnerSpec;
+        fromJSON(object: any): _124.InnerSpec;
+        toJSON(message: _124.InnerSpec): import("../json-safe.js").JsonSafe<_124.InnerSpec>;
+        fromPartial(object: Partial<_124.InnerSpec>): _124.InnerSpec;
+        fromProtoMsg(message: _124.InnerSpecProtoMsg): _124.InnerSpec;
+        toProto(message: _124.InnerSpec): Uint8Array;
+        toProtoMsg(message: _124.InnerSpec): _124.InnerSpecProtoMsg;
     };
     BatchProof: {
         typeUrl: string;
-        encode(message: _123.BatchProof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _123.BatchProof;
-        fromJSON(object: any): _123.BatchProof;
-        toJSON(message: _123.BatchProof): import("../json-safe.js").JsonSafe<_123.BatchProof>;
-        fromPartial(object: Partial<_123.BatchProof>): _123.BatchProof;
-        fromProtoMsg(message: _123.BatchProofProtoMsg): _123.BatchProof;
-        toProto(message: _123.BatchProof): Uint8Array;
-        toProtoMsg(message: _123.BatchProof): _123.BatchProofProtoMsg;
+        encode(message: _124.BatchProof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.BatchProof;
+        fromJSON(object: any): _124.BatchProof;
+        toJSON(message: _124.BatchProof): import("../json-safe.js").JsonSafe<_124.BatchProof>;
+        fromPartial(object: Partial<_124.BatchProof>): _124.BatchProof;
+        fromProtoMsg(message: _124.BatchProofProtoMsg): _124.BatchProof;
+        toProto(message: _124.BatchProof): Uint8Array;
+        toProtoMsg(message: _124.BatchProof): _124.BatchProofProtoMsg;
     };
     BatchEntry: {
         typeUrl: string;
-        encode(message: _123.BatchEntry, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _123.BatchEntry;
-        fromJSON(object: any): _123.BatchEntry;
-        toJSON(message: _123.BatchEntry): import("../json-safe.js").JsonSafe<_123.BatchEntry>;
-        fromPartial(object: Partial<_123.BatchEntry>): _123.BatchEntry;
-        fromProtoMsg(message: _123.BatchEntryProtoMsg): _123.BatchEntry;
-        toProto(message: _123.BatchEntry): Uint8Array;
-        toProtoMsg(message: _123.BatchEntry): _123.BatchEntryProtoMsg;
+        encode(message: _124.BatchEntry, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.BatchEntry;
+        fromJSON(object: any): _124.BatchEntry;
+        toJSON(message: _124.BatchEntry): import("../json-safe.js").JsonSafe<_124.BatchEntry>;
+        fromPartial(object: Partial<_124.BatchEntry>): _124.BatchEntry;
+        fromProtoMsg(message: _124.BatchEntryProtoMsg): _124.BatchEntry;
+        toProto(message: _124.BatchEntry): Uint8Array;
+        toProtoMsg(message: _124.BatchEntry): _124.BatchEntryProtoMsg;
     };
     CompressedBatchProof: {
         typeUrl: string;
-        encode(message: _123.CompressedBatchProof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _123.CompressedBatchProof;
-        fromJSON(object: any): _123.CompressedBatchProof;
-        toJSON(message: _123.CompressedBatchProof): import("../json-safe.js").JsonSafe<_123.CompressedBatchProof>;
-        fromPartial(object: Partial<_123.CompressedBatchProof>): _123.CompressedBatchProof;
-        fromProtoMsg(message: _123.CompressedBatchProofProtoMsg): _123.CompressedBatchProof;
-        toProto(message: _123.CompressedBatchProof): Uint8Array;
-        toProtoMsg(message: _123.CompressedBatchProof): _123.CompressedBatchProofProtoMsg;
+        encode(message: _124.CompressedBatchProof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.CompressedBatchProof;
+        fromJSON(object: any): _124.CompressedBatchProof;
+        toJSON(message: _124.CompressedBatchProof): import("../json-safe.js").JsonSafe<_124.CompressedBatchProof>;
+        fromPartial(object: Partial<_124.CompressedBatchProof>): _124.CompressedBatchProof;
+        fromProtoMsg(message: _124.CompressedBatchProofProtoMsg): _124.CompressedBatchProof;
+        toProto(message: _124.CompressedBatchProof): Uint8Array;
+        toProtoMsg(message: _124.CompressedBatchProof): _124.CompressedBatchProofProtoMsg;
     };
     CompressedBatchEntry: {
         typeUrl: string;
-        encode(message: _123.CompressedBatchEntry, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _123.CompressedBatchEntry;
-        fromJSON(object: any): _123.CompressedBatchEntry;
-        toJSON(message: _123.CompressedBatchEntry): import("../json-safe.js").JsonSafe<_123.CompressedBatchEntry>;
-        fromPartial(object: Partial<_123.CompressedBatchEntry>): _123.CompressedBatchEntry;
-        fromProtoMsg(message: _123.CompressedBatchEntryProtoMsg): _123.CompressedBatchEntry;
-        toProto(message: _123.CompressedBatchEntry): Uint8Array;
-        toProtoMsg(message: _123.CompressedBatchEntry): _123.CompressedBatchEntryProtoMsg;
+        encode(message: _124.CompressedBatchEntry, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.CompressedBatchEntry;
+        fromJSON(object: any): _124.CompressedBatchEntry;
+        toJSON(message: _124.CompressedBatchEntry): import("../json-safe.js").JsonSafe<_124.CompressedBatchEntry>;
+        fromPartial(object: Partial<_124.CompressedBatchEntry>): _124.CompressedBatchEntry;
+        fromProtoMsg(message: _124.CompressedBatchEntryProtoMsg): _124.CompressedBatchEntry;
+        toProto(message: _124.CompressedBatchEntry): Uint8Array;
+        toProtoMsg(message: _124.CompressedBatchEntry): _124.CompressedBatchEntryProtoMsg;
     };
     CompressedExistenceProof: {
         typeUrl: string;
-        encode(message: _123.CompressedExistenceProof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _123.CompressedExistenceProof;
-        fromJSON(object: any): _123.CompressedExistenceProof;
-        toJSON(message: _123.CompressedExistenceProof): import("../json-safe.js").JsonSafe<_123.CompressedExistenceProof>;
-        fromPartial(object: Partial<_123.CompressedExistenceProof>): _123.CompressedExistenceProof;
-        fromProtoMsg(message: _123.CompressedExistenceProofProtoMsg): _123.CompressedExistenceProof;
-        toProto(message: _123.CompressedExistenceProof): Uint8Array;
-        toProtoMsg(message: _123.CompressedExistenceProof): _123.CompressedExistenceProofProtoMsg;
+        encode(message: _124.CompressedExistenceProof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.CompressedExistenceProof;
+        fromJSON(object: any): _124.CompressedExistenceProof;
+        toJSON(message: _124.CompressedExistenceProof): import("../json-safe.js").JsonSafe<_124.CompressedExistenceProof>;
+        fromPartial(object: Partial<_124.CompressedExistenceProof>): _124.CompressedExistenceProof;
+        fromProtoMsg(message: _124.CompressedExistenceProofProtoMsg): _124.CompressedExistenceProof;
+        toProto(message: _124.CompressedExistenceProof): Uint8Array;
+        toProtoMsg(message: _124.CompressedExistenceProof): _124.CompressedExistenceProofProtoMsg;
     };
     CompressedNonExistenceProof: {
         typeUrl: string;
-        encode(message: _123.CompressedNonExistenceProof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _123.CompressedNonExistenceProof;
-        fromJSON(object: any): _123.CompressedNonExistenceProof;
-        toJSON(message: _123.CompressedNonExistenceProof): import("../json-safe.js").JsonSafe<_123.CompressedNonExistenceProof>;
-        fromPartial(object: Partial<_123.CompressedNonExistenceProof>): _123.CompressedNonExistenceProof;
-        fromProtoMsg(message: _123.CompressedNonExistenceProofProtoMsg): _123.CompressedNonExistenceProof;
-        toProto(message: _123.CompressedNonExistenceProof): Uint8Array;
-        toProtoMsg(message: _123.CompressedNonExistenceProof): _123.CompressedNonExistenceProofProtoMsg;
+        encode(message: _124.CompressedNonExistenceProof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.CompressedNonExistenceProof;
+        fromJSON(object: any): _124.CompressedNonExistenceProof;
+        toJSON(message: _124.CompressedNonExistenceProof): import("../json-safe.js").JsonSafe<_124.CompressedNonExistenceProof>;
+        fromPartial(object: Partial<_124.CompressedNonExistenceProof>): _124.CompressedNonExistenceProof;
+        fromProtoMsg(message: _124.CompressedNonExistenceProofProtoMsg): _124.CompressedNonExistenceProof;
+        toProto(message: _124.CompressedNonExistenceProof): Uint8Array;
+        toProtoMsg(message: _124.CompressedNonExistenceProof): _124.CompressedNonExistenceProofProtoMsg;
     };
 };

package/dist/codegen/ics23/bundle.js

@@ -1,6 +1,6 @@
 //@ts-nocheck
-import * as _123 from '../proofs.js';
+import * as _124 from '../proofs.js';
 export const ics23 = {
-    ..._123,
+    ..._124,
 };
 //# sourceMappingURL=bundle.js.map

package/dist/codegen/tendermint/abci/types.d.ts

@@ -1,3 +1,4 @@
+import { Timestamp, TimestampSDKType } from '../../google/protobuf/timestamp.js';
 import { Header, HeaderSDKType } from '../types/types.js';
 import { ProofOps, ProofOpsSDKType } from '../crypto/proof.js';
 import { EvidenceParams, EvidenceParamsSDKType, ValidatorParams, ValidatorParamsSDKType, VersionParams, VersionParamsSDKType } from '../types/params.js';
@@ -142,7 +143,7 @@ export interface RequestSetOptionSDKType {
     value: string;
 }
 export interface RequestInitChain {
-    time: Date;
+    time: Timestamp;
     chainId: string;
     consensusParams?: ConsensusParams;
     validators: ValidatorUpdate[];
@@ -154,7 +155,7 @@ export interface RequestInitChainProtoMsg {
     value: Uint8Array;
 }
 export interface RequestInitChainSDKType {
-    time: Date;
+    time: TimestampSDKType;
     chain_id: string;
     consensus_params?: ConsensusParamsSDKType;
     validators: ValidatorUpdateSDKType[];
@@ -744,7 +745,7 @@ export interface Evidence {
     /** The height when the offense occurred */
     height: bigint;
     /** The corresponding time where the offense occurred */
-    time: Date;
+    time: Timestamp;
     /**
      * Total voting power of the validator set in case the ABCI application does
      * not store historical validators.
@@ -760,7 +761,7 @@ export interface EvidenceSDKType {
     type: EvidenceType;
     validator: ValidatorSDKType;
     height: bigint;
-    time: Date;
+    time: TimestampSDKType;
     total_voting_power: bigint;
 }
 export interface Snapshot {

package/dist/codegen/tendermint/abci/types.js

@@ -1,11 +1,11 @@
 //@ts-nocheck
-import { Timestamp } from '../../google/protobuf/timestamp.js';
+import { Timestamp, } from '../../google/protobuf/timestamp.js';
 import { Header } from '../types/types.js';
 import { ProofOps } from '../crypto/proof.js';
 import { EvidenceParams, ValidatorParams, VersionParams, } from '../types/params.js';
 import { PublicKey } from '../crypto/keys.js';
 import { BinaryReader, BinaryWriter } from '../../binary.js';
-import { isSet, toTimestamp, fromTimestamp, fromJsonTimestamp, bytesFromBase64, base64FromBytes, } from '../../helpers.js';
+import { isSet, fromJsonTimestamp, bytesFromBase64, fromTimestamp, base64FromBytes, } from '../../helpers.js';
 export var CheckTxType;
 (function (CheckTxType) {
     CheckTxType[CheckTxType["NEW"] = 0] = "NEW";
@@ -776,7 +776,7 @@ export const RequestSetOption = {
 };
 function createBaseRequestInitChain() {
     return {
-        time: new Date(),
+        time: Timestamp.fromPartial({}),
         chainId: '',
         consensusParams: undefined,
         validators: [],
@@ -788,7 +788,7 @@ export const RequestInitChain = {
     typeUrl: '/tendermint.abci.RequestInitChain',
     encode(message, writer = BinaryWriter.create()) {
         if (message.time !== undefined) {
-            Timestamp.encode(toTimestamp(message.time), writer.uint32(10).fork()).ldelim();
+            Timestamp.encode(message.time, writer.uint32(10).fork()).ldelim();
         }
         if (message.chainId !== '') {
             writer.uint32(18).string(message.chainId);
@@ -815,7 +815,7 @@ export const RequestInitChain = {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    message.time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    message.time = Timestamp.decode(reader, reader.uint32());
                     break;
                 case 2:
                     message.chainId = reader.string();
@@ -859,7 +859,8 @@ export const RequestInitChain = {
     },
     toJSON(message) {
         const obj = {};
-        message.time !== undefined && (obj.time = message.time.toISOString());
+        message.time !== undefined &&
+            (obj.time = fromTimestamp(message.time).toISOString());
         message.chainId !== undefined && (obj.chainId = message.chainId);
         message.consensusParams !== undefined &&
             (obj.consensusParams = message.consensusParams
@@ -881,7 +882,10 @@ export const RequestInitChain = {
     },
     fromPartial(object) {
         const message = createBaseRequestInitChain();
-        message.time = object.time ?? undefined;
+        message.time =
+            object.time !== undefined && object.time !== null
+                ? Timestamp.fromPartial(object.time)
+                : undefined;
         message.chainId = object.chainId ?? '';
         message.consensusParams =
             object.consensusParams !== undefined && object.consensusParams !== null
@@ -4199,7 +4203,7 @@ function createBaseEvidence() {
         type: 0,
         validator: Validator.fromPartial({}),
         height: BigInt(0),
-        time: new Date(),
+        time: Timestamp.fromPartial({}),
         totalVotingPower: BigInt(0),
     };
 }
@@ -4216,7 +4220,7 @@ export const Evidence = {
             writer.uint32(24).int64(message.height);
         }
         if (message.time !== undefined) {
-            Timestamp.encode(toTimestamp(message.time), writer.uint32(34).fork()).ldelim();
+            Timestamp.encode(message.time, writer.uint32(34).fork()).ldelim();
         }
         if (message.totalVotingPower !== BigInt(0)) {
             writer.uint32(40).int64(message.totalVotingPower);
@@ -4240,7 +4244,7 @@ export const Evidence = {
                     message.height = reader.int64();
                     break;
                 case 4:
-                    message.time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    message.time = Timestamp.decode(reader, reader.uint32());
                     break;
                 case 5:
                     message.totalVotingPower = reader.int64();
@@ -4276,7 +4280,8 @@ export const Evidence = {
                 : undefined);
         message.height !== undefined &&
             (obj.height = (message.height || BigInt(0)).toString());
-        message.time !== undefined && (obj.time = message.time.toISOString());
+        message.time !== undefined &&
+            (obj.time = fromTimestamp(message.time).toISOString());
         message.totalVotingPower !== undefined &&
             (obj.totalVotingPower = (message.totalVotingPower || BigInt(0)).toString());
         return obj;
@@ -4292,7 +4297,10 @@ export const Evidence = {
             object.height !== undefined && object.height !== null
                 ? BigInt(object.height.toString())
                 : BigInt(0);
-        message.time = object.time ?? undefined;
+        message.time =
+            object.time !== undefined && object.time !== null
+                ? Timestamp.fromPartial(object.time)
+                : undefined;
         message.totalVotingPower =
             object.totalVotingPower !== undefined && object.totalVotingPower !== null
                 ? BigInt(object.totalVotingPower.toString())