@inco/js 0.2.16 → 0.3.0

package/dist/types/generated/ts/cometbft/types/v1/params.d.ts

@@ -0,0 +1,179 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { Duration } from "../../../google/protobuf/duration";
+export declare const protobufPackage = "cometbft.types.v1";
+/**
+ * ConsensusParams contains consensus critical parameters that determine the
+ * validity of blocks.
+ */
+export interface ConsensusParams {
+    block: BlockParams | undefined;
+    evidence: EvidenceParams | undefined;
+    validator: ValidatorParams | undefined;
+    version: VersionParams | undefined;
+    /**
+     * Use FeatureParams.vote_extensions_enable_height instead
+     *
+     * @deprecated
+     */
+    abci: ABCIParams | undefined;
+    synchrony: SynchronyParams | undefined;
+    feature: FeatureParams | undefined;
+}
+/** BlockParams define limits on the block size and gas. */
+export interface BlockParams {
+    /**
+     * Maximum size of a block, in bytes.
+     *
+     * Must be greater or equal to -1 and cannot be greater than the hard-coded
+     * maximum block size, which is 100MB.
+     *
+     * If set to -1, the limit is the hard-coded maximum block size.
+     */
+    maxBytes: number;
+    /**
+     * Maximum gas wanted by transactions included in a block.
+     *
+     * Must be greater or equal to -1. If set to -1, no limit is enforced.
+     */
+    maxGas: number;
+}
+/** EvidenceParams determine the validity of evidences of Byzantine behavior. */
+export interface EvidenceParams {
+    /**
+     * Maximum age of evidence, in blocks.
+     *
+     * The recommended formula for calculating it is max_age_duration / {average
+     * block time}.
+     */
+    maxAgeNumBlocks: number;
+    /**
+     * Maximum age of evidence, in time.
+     *
+     * The recommended value of is should correspond to the application's
+     * "unbonding period" or other similar mechanism for handling
+     * Nothing-At-Stake attacks.
+     * See: https://github.com/ethereum/wiki/wiki/Proof-of-Stake-FAQ#what-is-the-nothing-at-stake-problem-and-how-can-it-be-fixed.
+     */
+    maxAgeDuration: Duration | undefined;
+    /**
+     * Maximum size in bytes of evidence allowed to be included in a block.
+     *
+     * It should fall comfortably under the maximum size of a block.
+     */
+    maxBytes: number;
+}
+/**
+ * ValidatorParams restrict the public key types validators can use.
+ *
+ * NOTE: uses ABCI public keys naming, not Amino names.
+ */
+export interface ValidatorParams {
+    pubKeyTypes: string[];
+}
+/** VersionParams contain the version of specific components of CometBFT. */
+export interface VersionParams {
+    /**
+     * The ABCI application version.
+     *
+     * It was named app_version in CometBFT 0.34.
+     */
+    app: number;
+}
+/**
+ * HashedParams is a subset of ConsensusParams.
+ *
+ * It is hashed into the Header.ConsensusHash.
+ */
+export interface HashedParams {
+    blockMaxBytes: number;
+    blockMaxGas: number;
+}
+/**
+ * SynchronyParams determine the validity of block timestamps.
+ *
+ * These parameters are part of the Proposer-Based Timestamps (PBTS) algorithm.
+ * For more information on the relationship of the synchrony parameters to
+ * block timestamps validity, refer to the PBTS specification:
+ * https://github.com/tendermint/spec/blob/master/spec/consensus/proposer-based-timestamp/README.md
+ */
+export interface SynchronyParams {
+    /**
+     * Bound for how skewed a proposer's clock may be from any validator on the
+     * network while still producing valid proposals.
+     */
+    precision: Duration | undefined;
+    /**
+     * Bound for how long a proposal message may take to reach all validators on
+     * a network and still be considered valid.
+     */
+    messageDelay: Duration | undefined;
+}
+/** FeatureParams configure the height from which features of CometBFT are enabled. */
+export interface FeatureParams {
+    /**
+     * First height during which vote extensions will be enabled.
+     *
+     * During the specified height, and for all subsequent heights, precommit
+     * messages that do not contain valid extension data will be considered
+     * invalid. Prior to this height, or when this height is set to 0, vote
+     * extensions will not be used or accepted by validators on the network.
+     *
+     * Once enabled, vote extensions will be created by the application in
+     * ExtendVote, validated by the application in VerifyVoteExtension, and
+     * used by the application in PrepareProposal, when proposing the next block.
+     *
+     * Cannot be set to heights lower or equal to the current blockchain height.
+     */
+    voteExtensionsEnableHeight: number | undefined;
+    /**
+     * Height at which Proposer-Based Timestamps (PBTS) will be enabled.
+     *
+     * From the specified height, and for all subsequent heights, the PBTS
+     * algorithm will be used to produce and validate block timestamps. Prior to
+     * this height, or when this height is set to 0, the legacy BFT Time
+     * algorithm is used to produce and validate timestamps.
+     *
+     * Cannot be set to heights lower or equal to the current blockchain height.
+     */
+    pbtsEnableHeight: number | undefined;
+}
+/**
+ * ABCIParams is deprecated and its contents moved to FeatureParams
+ *
+ * @deprecated
+ */
+export interface ABCIParams {
+    /**
+     * vote_extensions_enable_height has been deprecated.
+     * Instead, use FeatureParams.vote_extensions_enable_height.
+     */
+    voteExtensionsEnableHeight: number;
+}
+export declare const ConsensusParams: MessageFns<ConsensusParams>;
+export declare const BlockParams: MessageFns<BlockParams>;
+export declare const EvidenceParams: MessageFns<EvidenceParams>;
+export declare const ValidatorParams: MessageFns<ValidatorParams>;
+export declare const VersionParams: MessageFns<VersionParams>;
+export declare const HashedParams: MessageFns<HashedParams>;
+export declare const SynchronyParams: MessageFns<SynchronyParams>;
+export declare const FeatureParams: MessageFns<FeatureParams>;
+export declare const ABCIParams: MessageFns<ABCIParams>;
+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;
+}
+export {};

package/dist/types/generated/ts/cometbft/types/v1/validator.d.ts

@@ -0,0 +1,61 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { PublicKey } from "../../crypto/v1/keys";
+export declare const protobufPackage = "cometbft.types.v1";
+/** BlockIdFlag indicates which BlockID the signature is for */
+export declare enum BlockIDFlag {
+    /** BLOCK_ID_FLAG_UNKNOWN - Indicates an error condition */
+    BLOCK_ID_FLAG_UNKNOWN = 0,
+    /** BLOCK_ID_FLAG_ABSENT - The vote was not received */
+    BLOCK_ID_FLAG_ABSENT = 1,
+    /** BLOCK_ID_FLAG_COMMIT - Voted for the block that received the majority */
+    BLOCK_ID_FLAG_COMMIT = 2,
+    /** BLOCK_ID_FLAG_NIL - Voted for nil */
+    BLOCK_ID_FLAG_NIL = 3,
+    UNRECOGNIZED = -1
+}
+export declare function blockIDFlagFromJSON(object: any): BlockIDFlag;
+export declare function blockIDFlagToJSON(object: BlockIDFlag): string;
+/** ValidatorSet defines a set of validators. */
+export interface ValidatorSet {
+    validators: Validator[];
+    proposer: Validator | undefined;
+    totalVotingPower: number;
+}
+/** Validator represents a node participating in the consensus protocol. */
+export interface Validator {
+    address: Uint8Array;
+    pubKey: PublicKey | undefined;
+    votingPower: number;
+    proposerPriority: number;
+}
+/**
+ * SimpleValidator is a Validator, which is serialized and hashed in consensus.
+ * Address is removed because it's redundant with the pubkey.
+ * Proposer priority is removed because it changes every round.
+ */
+export interface SimpleValidator {
+    pubKey: PublicKey | undefined;
+    votingPower: number;
+}
+export declare const ValidatorSet: MessageFns<ValidatorSet>;
+export declare const Validator: MessageFns<Validator>;
+export declare const SimpleValidator: MessageFns<SimpleValidator>;
+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;
+}
+export {};

package/dist/types/generated/ts/cosmos/app/v1alpha1/module.d.ts

@@ -0,0 +1,104 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "cosmos.app.v1alpha1";
+/** ModuleDescriptor describes an app module. */
+export interface ModuleDescriptor {
+    /**
+     * go_import names the package that should be imported by an app to load the
+     * module in the runtime module registry. It is required to make debugging
+     * of configuration errors easier for users.
+     */
+    goImport: string;
+    /**
+     * use_package refers to a protobuf package that this module
+     * uses and exposes to the world. In an app, only one module should "use"
+     * or own a single protobuf package. It is assumed that the module uses
+     * all of the .proto files in a single package.
+     */
+    usePackage: PackageReference[];
+    /**
+     * can_migrate_from defines which module versions this module can migrate
+     * state from. The framework will check that one module version is able to
+     * migrate from a previous module version before attempting to update its
+     * config. It is assumed that modules can transitively migrate from earlier
+     * versions. For instance if v3 declares it can migrate from v2, and v2
+     * declares it can migrate from v1, the framework knows how to migrate
+     * from v1 to v3, assuming all 3 module versions are registered at runtime.
+     */
+    canMigrateFrom: MigrateFromInfo[];
+}
+/** PackageReference is a reference to a protobuf package used by a module. */
+export interface PackageReference {
+    /** name is the fully-qualified name of the package. */
+    name: string;
+    /**
+     * revision is the optional revision of the package that is being used.
+     * Protobuf packages used in Cosmos should generally have a major version
+     * as the last part of the package name, ex. foo.bar.baz.v1.
+     * The revision of a package can be thought of as the minor version of a
+     * package which has additional backwards compatible definitions that weren't
+     * present in a previous version.
+     *
+     * A package should indicate its revision with a source code comment
+     * above the package declaration in one of its files containing the
+     * text "Revision N" where N is an integer revision. All packages start
+     * at revision 0 the first time they are released in a module.
+     *
+     * When a new version of a module is released and items are added to existing
+     * .proto files, these definitions should contain comments of the form
+     * "Since: Revision N" where N is an integer revision.
+     *
+     * When the module runtime starts up, it will check the pinned proto
+     * image and panic if there are runtime protobuf definitions that are not
+     * in the pinned descriptor which do not have
+     * a "Since Revision N" comment or have a "Since Revision N" comment where
+     * N is <= to the revision specified here. This indicates that the protobuf
+     * files have been updated, but the pinned file descriptor hasn't.
+     *
+     * If there are items in the pinned file descriptor with a revision
+     * greater than the value indicated here, this will also cause a panic
+     * as it may mean that the pinned descriptor for a legacy module has been
+     * improperly updated or that there is some other versioning discrepancy.
+     * Runtime protobuf definitions will also be checked for compatibility
+     * with pinned file descriptors to make sure there are no incompatible changes.
+     *
+     * This behavior ensures that:
+     * * pinned proto images are up-to-date
+     * * protobuf files are carefully annotated with revision comments which
+     *   are important good client UX
+     * * protobuf files are changed in backwards and forwards compatible ways
+     */
+    revision: number;
+}
+/**
+ * MigrateFromInfo is information on a module version that a newer module
+ * can migrate from.
+ */
+export interface MigrateFromInfo {
+    /**
+     * module is the fully-qualified protobuf name of the module config object
+     * for the previous module version, ex: "cosmos.group.module.v1.Module".
+     */
+    module: string;
+}
+export declare const ModuleDescriptor: MessageFns<ModuleDescriptor>;
+export declare const PackageReference: MessageFns<PackageReference>;
+export declare const MigrateFromInfo: MessageFns<MigrateFromInfo>;
+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;
+}
+export {};

package/dist/types/generated/ts/cosmos/msg/v1/msg.d.ts

@@ -0,0 +1 @@
+export declare const protobufPackage = "cosmos.msg.v1";

package/dist/types/generated/ts/cosmos_proto/cosmos.d.ts

@@ -0,0 +1,80 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "cosmos_proto";
+export declare enum ScalarType {
+    SCALAR_TYPE_UNSPECIFIED = 0,
+    SCALAR_TYPE_STRING = 1,
+    SCALAR_TYPE_BYTES = 2,
+    UNRECOGNIZED = -1
+}
+export declare function scalarTypeFromJSON(object: any): ScalarType;
+export declare function scalarTypeToJSON(object: ScalarType): string;
+/**
+ * InterfaceDescriptor describes an interface type to be used with
+ * accepts_interface and implements_interface and declared by declare_interface.
+ */
+export interface InterfaceDescriptor {
+    /**
+     * name is the name of the interface. It should be a short-name (without
+     * a period) such that the fully qualified name of the interface will be
+     * package.name, ex. for the package a.b and interface named C, the
+     * fully-qualified name will be a.b.C.
+     */
+    name: string;
+    /**
+     * description is a human-readable description of the interface and its
+     * purpose.
+     */
+    description: string;
+}
+/**
+ * ScalarDescriptor describes an scalar type to be used with
+ * the scalar field option and declared by declare_scalar.
+ * Scalars extend simple protobuf built-in types with additional
+ * syntax and semantics, for instance to represent big integers.
+ * Scalars should ideally define an encoding such that there is only one
+ * valid syntactical representation for a given semantic meaning,
+ * i.e. the encoding should be deterministic.
+ */
+export interface ScalarDescriptor {
+    /**
+     * name is the name of the scalar. It should be a short-name (without
+     * a period) such that the fully qualified name of the scalar will be
+     * package.name, ex. for the package a.b and scalar named C, the
+     * fully-qualified name will be a.b.C.
+     */
+    name: string;
+    /**
+     * description is a human-readable description of the scalar and its
+     * encoding format. For instance a big integer or decimal scalar should
+     * specify precisely the expected encoding format.
+     */
+    description: string;
+    /**
+     * field_type is the type of field with which this scalar can be used.
+     * Scalars can be used with one and only one type of field so that
+     * encoding standards and simple and clear. Currently only string and
+     * bytes fields are supported for scalars.
+     */
+    fieldType: ScalarType[];
+}
+export declare const InterfaceDescriptor: MessageFns<InterfaceDescriptor>;
+export declare const ScalarDescriptor: MessageFns<ScalarDescriptor>;
+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;
+}
+export {};

package/dist/types/generated/ts/gogoproto/gogo.d.ts

@@ -0,0 +1 @@
+export declare const protobufPackage = "gogoproto";

package/dist/types/generated/ts/google/api/annotations.d.ts

@@ -0,0 +1 @@
+export declare const protobufPackage = "google.api";