@agoric/cosmic-proto 0.4.1-dev-a477bee.0 → 0.4.1-dev-2b7439e.0

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

@@ -0,0 +1,654 @@
+//@ts-nocheck
+import { Timestamp } from '../../google/protobuf/timestamp.js';
+import { BinaryReader, BinaryWriter } from '../../binary.js';
+import { isSet, bytesFromBase64, base64FromBytes, toTimestamp, fromTimestamp, fromJsonTimestamp, } from '../../helpers.js';
+function createBaseProtocolVersion() {
+    return {
+        p2p: BigInt(0),
+        block: BigInt(0),
+        app: BigInt(0),
+    };
+}
+export const ProtocolVersion = {
+    typeUrl: '/tendermint.p2p.ProtocolVersion',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.p2p !== BigInt(0)) {
+            writer.uint32(8).uint64(message.p2p);
+        }
+        if (message.block !== BigInt(0)) {
+            writer.uint32(16).uint64(message.block);
+        }
+        if (message.app !== BigInt(0)) {
+            writer.uint32(24).uint64(message.app);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseProtocolVersion();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.p2p = reader.uint64();
+                    break;
+                case 2:
+                    message.block = reader.uint64();
+                    break;
+                case 3:
+                    message.app = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            p2p: isSet(object.p2p) ? BigInt(object.p2p.toString()) : BigInt(0),
+            block: isSet(object.block) ? BigInt(object.block.toString()) : BigInt(0),
+            app: isSet(object.app) ? BigInt(object.app.toString()) : BigInt(0),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.p2p !== undefined &&
+            (obj.p2p = (message.p2p || BigInt(0)).toString());
+        message.block !== undefined &&
+            (obj.block = (message.block || BigInt(0)).toString());
+        message.app !== undefined &&
+            (obj.app = (message.app || BigInt(0)).toString());
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseProtocolVersion();
+        message.p2p =
+            object.p2p !== undefined && object.p2p !== null
+                ? BigInt(object.p2p.toString())
+                : BigInt(0);
+        message.block =
+            object.block !== undefined && object.block !== null
+                ? BigInt(object.block.toString())
+                : BigInt(0);
+        message.app =
+            object.app !== undefined && object.app !== null
+                ? BigInt(object.app.toString())
+                : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseProtocolVersion();
+        if (object.p2p !== undefined && object.p2p !== null) {
+            message.p2p = BigInt(object.p2p);
+        }
+        if (object.block !== undefined && object.block !== null) {
+            message.block = BigInt(object.block);
+        }
+        if (object.app !== undefined && object.app !== null) {
+            message.app = BigInt(object.app);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.p2p = message.p2p !== BigInt(0) ? message.p2p.toString() : undefined;
+        obj.block =
+            message.block !== BigInt(0) ? message.block.toString() : undefined;
+        obj.app = message.app !== BigInt(0) ? message.app.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ProtocolVersion.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ProtocolVersion.decode(message.value);
+    },
+    toProto(message) {
+        return ProtocolVersion.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.p2p.ProtocolVersion',
+            value: ProtocolVersion.encode(message).finish(),
+        };
+    },
+};
+function createBaseNodeInfo() {
+    return {
+        protocolVersion: ProtocolVersion.fromPartial({}),
+        nodeId: '',
+        listenAddr: '',
+        network: '',
+        version: '',
+        channels: new Uint8Array(),
+        moniker: '',
+        other: NodeInfoOther.fromPartial({}),
+    };
+}
+export const NodeInfo = {
+    typeUrl: '/tendermint.p2p.NodeInfo',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.protocolVersion !== undefined) {
+            ProtocolVersion.encode(message.protocolVersion, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.nodeId !== '') {
+            writer.uint32(18).string(message.nodeId);
+        }
+        if (message.listenAddr !== '') {
+            writer.uint32(26).string(message.listenAddr);
+        }
+        if (message.network !== '') {
+            writer.uint32(34).string(message.network);
+        }
+        if (message.version !== '') {
+            writer.uint32(42).string(message.version);
+        }
+        if (message.channels.length !== 0) {
+            writer.uint32(50).bytes(message.channels);
+        }
+        if (message.moniker !== '') {
+            writer.uint32(58).string(message.moniker);
+        }
+        if (message.other !== undefined) {
+            NodeInfoOther.encode(message.other, writer.uint32(66).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseNodeInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.protocolVersion = ProtocolVersion.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.nodeId = reader.string();
+                    break;
+                case 3:
+                    message.listenAddr = reader.string();
+                    break;
+                case 4:
+                    message.network = reader.string();
+                    break;
+                case 5:
+                    message.version = reader.string();
+                    break;
+                case 6:
+                    message.channels = reader.bytes();
+                    break;
+                case 7:
+                    message.moniker = reader.string();
+                    break;
+                case 8:
+                    message.other = NodeInfoOther.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            protocolVersion: isSet(object.protocolVersion)
+                ? ProtocolVersion.fromJSON(object.protocolVersion)
+                : undefined,
+            nodeId: isSet(object.nodeId) ? String(object.nodeId) : '',
+            listenAddr: isSet(object.listenAddr) ? String(object.listenAddr) : '',
+            network: isSet(object.network) ? String(object.network) : '',
+            version: isSet(object.version) ? String(object.version) : '',
+            channels: isSet(object.channels)
+                ? bytesFromBase64(object.channels)
+                : new Uint8Array(),
+            moniker: isSet(object.moniker) ? String(object.moniker) : '',
+            other: isSet(object.other)
+                ? NodeInfoOther.fromJSON(object.other)
+                : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.protocolVersion !== undefined &&
+            (obj.protocolVersion = message.protocolVersion
+                ? ProtocolVersion.toJSON(message.protocolVersion)
+                : undefined);
+        message.nodeId !== undefined && (obj.nodeId = message.nodeId);
+        message.listenAddr !== undefined && (obj.listenAddr = message.listenAddr);
+        message.network !== undefined && (obj.network = message.network);
+        message.version !== undefined && (obj.version = message.version);
+        message.channels !== undefined &&
+            (obj.channels = base64FromBytes(message.channels !== undefined ? message.channels : new Uint8Array()));
+        message.moniker !== undefined && (obj.moniker = message.moniker);
+        message.other !== undefined &&
+            (obj.other = message.other
+                ? NodeInfoOther.toJSON(message.other)
+                : undefined);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseNodeInfo();
+        message.protocolVersion =
+            object.protocolVersion !== undefined && object.protocolVersion !== null
+                ? ProtocolVersion.fromPartial(object.protocolVersion)
+                : undefined;
+        message.nodeId = object.nodeId ?? '';
+        message.listenAddr = object.listenAddr ?? '';
+        message.network = object.network ?? '';
+        message.version = object.version ?? '';
+        message.channels = object.channels ?? new Uint8Array();
+        message.moniker = object.moniker ?? '';
+        message.other =
+            object.other !== undefined && object.other !== null
+                ? NodeInfoOther.fromPartial(object.other)
+                : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseNodeInfo();
+        if (object.protocol_version !== undefined &&
+            object.protocol_version !== null) {
+            message.protocolVersion = ProtocolVersion.fromAmino(object.protocol_version);
+        }
+        if (object.node_id !== undefined && object.node_id !== null) {
+            message.nodeId = object.node_id;
+        }
+        if (object.listen_addr !== undefined && object.listen_addr !== null) {
+            message.listenAddr = object.listen_addr;
+        }
+        if (object.network !== undefined && object.network !== null) {
+            message.network = object.network;
+        }
+        if (object.version !== undefined && object.version !== null) {
+            message.version = object.version;
+        }
+        if (object.channels !== undefined && object.channels !== null) {
+            message.channels = bytesFromBase64(object.channels);
+        }
+        if (object.moniker !== undefined && object.moniker !== null) {
+            message.moniker = object.moniker;
+        }
+        if (object.other !== undefined && object.other !== null) {
+            message.other = NodeInfoOther.fromAmino(object.other);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.protocol_version = message.protocolVersion
+            ? ProtocolVersion.toAmino(message.protocolVersion)
+            : undefined;
+        obj.node_id = message.nodeId === '' ? undefined : message.nodeId;
+        obj.listen_addr =
+            message.listenAddr === '' ? undefined : message.listenAddr;
+        obj.network = message.network === '' ? undefined : message.network;
+        obj.version = message.version === '' ? undefined : message.version;
+        obj.channels = message.channels
+            ? base64FromBytes(message.channels)
+            : undefined;
+        obj.moniker = message.moniker === '' ? undefined : message.moniker;
+        obj.other = message.other
+            ? NodeInfoOther.toAmino(message.other)
+            : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return NodeInfo.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return NodeInfo.decode(message.value);
+    },
+    toProto(message) {
+        return NodeInfo.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.p2p.NodeInfo',
+            value: NodeInfo.encode(message).finish(),
+        };
+    },
+};
+function createBaseNodeInfoOther() {
+    return {
+        txIndex: '',
+        rpcAddress: '',
+    };
+}
+export const NodeInfoOther = {
+    typeUrl: '/tendermint.p2p.NodeInfoOther',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.txIndex !== '') {
+            writer.uint32(10).string(message.txIndex);
+        }
+        if (message.rpcAddress !== '') {
+            writer.uint32(18).string(message.rpcAddress);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseNodeInfoOther();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.txIndex = reader.string();
+                    break;
+                case 2:
+                    message.rpcAddress = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            txIndex: isSet(object.txIndex) ? String(object.txIndex) : '',
+            rpcAddress: isSet(object.rpcAddress) ? String(object.rpcAddress) : '',
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.txIndex !== undefined && (obj.txIndex = message.txIndex);
+        message.rpcAddress !== undefined && (obj.rpcAddress = message.rpcAddress);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseNodeInfoOther();
+        message.txIndex = object.txIndex ?? '';
+        message.rpcAddress = object.rpcAddress ?? '';
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseNodeInfoOther();
+        if (object.tx_index !== undefined && object.tx_index !== null) {
+            message.txIndex = object.tx_index;
+        }
+        if (object.rpc_address !== undefined && object.rpc_address !== null) {
+            message.rpcAddress = object.rpc_address;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.tx_index = message.txIndex === '' ? undefined : message.txIndex;
+        obj.rpc_address =
+            message.rpcAddress === '' ? undefined : message.rpcAddress;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return NodeInfoOther.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return NodeInfoOther.decode(message.value);
+    },
+    toProto(message) {
+        return NodeInfoOther.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.p2p.NodeInfoOther',
+            value: NodeInfoOther.encode(message).finish(),
+        };
+    },
+};
+function createBasePeerInfo() {
+    return {
+        id: '',
+        addressInfo: [],
+        lastConnected: undefined,
+    };
+}
+export const PeerInfo = {
+    typeUrl: '/tendermint.p2p.PeerInfo',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== '') {
+            writer.uint32(10).string(message.id);
+        }
+        for (const v of message.addressInfo) {
+            PeerAddressInfo.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.lastConnected !== undefined) {
+            Timestamp.encode(toTimestamp(message.lastConnected), writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePeerInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = reader.string();
+                    break;
+                case 2:
+                    message.addressInfo.push(PeerAddressInfo.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.lastConnected = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            id: isSet(object.id) ? String(object.id) : '',
+            addressInfo: Array.isArray(object?.addressInfo)
+                ? object.addressInfo.map((e) => PeerAddressInfo.fromJSON(e))
+                : [],
+            lastConnected: isSet(object.lastConnected)
+                ? fromJsonTimestamp(object.lastConnected)
+                : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.id !== undefined && (obj.id = message.id);
+        if (message.addressInfo) {
+            obj.addressInfo = message.addressInfo.map(e => e ? PeerAddressInfo.toJSON(e) : undefined);
+        }
+        else {
+            obj.addressInfo = [];
+        }
+        message.lastConnected !== undefined &&
+            (obj.lastConnected = message.lastConnected.toISOString());
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBasePeerInfo();
+        message.id = object.id ?? '';
+        message.addressInfo =
+            object.addressInfo?.map(e => PeerAddressInfo.fromPartial(e)) || [];
+        message.lastConnected = object.lastConnected ?? undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePeerInfo();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = object.id;
+        }
+        message.addressInfo =
+            object.address_info?.map(e => PeerAddressInfo.fromAmino(e)) || [];
+        if (object.last_connected !== undefined && object.last_connected !== null) {
+            message.lastConnected = fromTimestamp(Timestamp.fromAmino(object.last_connected));
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id === '' ? undefined : message.id;
+        if (message.addressInfo) {
+            obj.address_info = message.addressInfo.map(e => e ? PeerAddressInfo.toAmino(e) : undefined);
+        }
+        else {
+            obj.address_info = message.addressInfo;
+        }
+        obj.last_connected = message.lastConnected
+            ? Timestamp.toAmino(toTimestamp(message.lastConnected))
+            : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return PeerInfo.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return PeerInfo.decode(message.value);
+    },
+    toProto(message) {
+        return PeerInfo.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.p2p.PeerInfo',
+            value: PeerInfo.encode(message).finish(),
+        };
+    },
+};
+function createBasePeerAddressInfo() {
+    return {
+        address: '',
+        lastDialSuccess: undefined,
+        lastDialFailure: undefined,
+        dialFailures: 0,
+    };
+}
+export const PeerAddressInfo = {
+    typeUrl: '/tendermint.p2p.PeerAddressInfo',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.address !== '') {
+            writer.uint32(10).string(message.address);
+        }
+        if (message.lastDialSuccess !== undefined) {
+            Timestamp.encode(toTimestamp(message.lastDialSuccess), writer.uint32(18).fork()).ldelim();
+        }
+        if (message.lastDialFailure !== undefined) {
+            Timestamp.encode(toTimestamp(message.lastDialFailure), writer.uint32(26).fork()).ldelim();
+        }
+        if (message.dialFailures !== 0) {
+            writer.uint32(32).uint32(message.dialFailures);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePeerAddressInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.address = reader.string();
+                    break;
+                case 2:
+                    message.lastDialSuccess = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.lastDialFailure = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.dialFailures = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            address: isSet(object.address) ? String(object.address) : '',
+            lastDialSuccess: isSet(object.lastDialSuccess)
+                ? fromJsonTimestamp(object.lastDialSuccess)
+                : undefined,
+            lastDialFailure: isSet(object.lastDialFailure)
+                ? fromJsonTimestamp(object.lastDialFailure)
+                : undefined,
+            dialFailures: isSet(object.dialFailures)
+                ? Number(object.dialFailures)
+                : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.address !== undefined && (obj.address = message.address);
+        message.lastDialSuccess !== undefined &&
+            (obj.lastDialSuccess = message.lastDialSuccess.toISOString());
+        message.lastDialFailure !== undefined &&
+            (obj.lastDialFailure = message.lastDialFailure.toISOString());
+        message.dialFailures !== undefined &&
+            (obj.dialFailures = Math.round(message.dialFailures));
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBasePeerAddressInfo();
+        message.address = object.address ?? '';
+        message.lastDialSuccess = object.lastDialSuccess ?? undefined;
+        message.lastDialFailure = object.lastDialFailure ?? undefined;
+        message.dialFailures = object.dialFailures ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePeerAddressInfo();
+        if (object.address !== undefined && object.address !== null) {
+            message.address = object.address;
+        }
+        if (object.last_dial_success !== undefined &&
+            object.last_dial_success !== null) {
+            message.lastDialSuccess = fromTimestamp(Timestamp.fromAmino(object.last_dial_success));
+        }
+        if (object.last_dial_failure !== undefined &&
+            object.last_dial_failure !== null) {
+            message.lastDialFailure = fromTimestamp(Timestamp.fromAmino(object.last_dial_failure));
+        }
+        if (object.dial_failures !== undefined && object.dial_failures !== null) {
+            message.dialFailures = object.dial_failures;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.address = message.address === '' ? undefined : message.address;
+        obj.last_dial_success = message.lastDialSuccess
+            ? Timestamp.toAmino(toTimestamp(message.lastDialSuccess))
+            : undefined;
+        obj.last_dial_failure = message.lastDialFailure
+            ? Timestamp.toAmino(toTimestamp(message.lastDialFailure))
+            : undefined;
+        obj.dial_failures =
+            message.dialFailures === 0 ? undefined : message.dialFailures;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return PeerAddressInfo.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return PeerAddressInfo.decode(message.value);
+    },
+    toProto(message) {
+        return PeerAddressInfo.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.p2p.PeerAddressInfo',
+            value: PeerAddressInfo.encode(message).finish(),
+        };
+    },
+};
+//# sourceMappingURL=types.js.map