@bandprotocol/bandchain.js/esm/codegen/band/tunnel/v1beta1/route.js

TypeScript library for Cosmos SDK and BandChain

import { Price } from "../../feeds/v1beta1/feeds";
import { Coin } from "../../../cosmos/base/v1beta1/coin";
import { BinaryReader, BinaryWriter } from "../../../binary";
function createBaseTSSRoute() {
    return {
        $typeUrl: "/band.tunnel.v1beta1.TSSRoute",
        destinationChainId: "",
        destinationContractAddress: "",
        encoder: 0
    };
}
export const TSSRoute = {
    typeUrl: "/band.tunnel.v1beta1.TSSRoute",
    encode(message, writer = BinaryWriter.create()) {
        if (message.destinationChainId !== "") {
            writer.uint32(10).string(message.destinationChainId);
        }
        if (message.destinationContractAddress !== "") {
            writer.uint32(18).string(message.destinationContractAddress);
        }
        if (message.encoder !== 0) {
            writer.uint32(24).int32(message.encoder);
        }
        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 = createBaseTSSRoute();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.destinationChainId = reader.string();
                    break;
                case 2:
                    message.destinationContractAddress = reader.string();
                    break;
                case 3:
                    message.encoder = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseTSSRoute();
        message.destinationChainId = object.destinationChainId ?? "";
        message.destinationContractAddress = object.destinationContractAddress ?? "";
        message.encoder = object.encoder ?? 0;
        return message;
    },
    fromAmino(object) {
        const message = createBaseTSSRoute();
        if (object.destination_chain_id !== undefined && object.destination_chain_id !== null) {
            message.destinationChainId = object.destination_chain_id;
        }
        if (object.destination_contract_address !== undefined && object.destination_contract_address !== null) {
            message.destinationContractAddress = object.destination_contract_address;
        }
        if (object.encoder !== undefined && object.encoder !== null) {
            message.encoder = object.encoder;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.destination_chain_id = message.destinationChainId === "" ? undefined : message.destinationChainId;
        obj.destination_contract_address = message.destinationContractAddress === "" ? undefined : message.destinationContractAddress;
        obj.encoder = message.encoder === 0 ? undefined : message.encoder;
        return obj;
    },
    fromAminoMsg(object) {
        return TSSRoute.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return TSSRoute.decode(message.value);
    },
    toProto(message) {
        return TSSRoute.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.TSSRoute",
            value: TSSRoute.encode(message).finish()
        };
    }
};
function createBaseTSSPacketReceipt() {
    return {
        $typeUrl: "/band.tunnel.v1beta1.TSSPacketReceipt",
        signingId: BigInt(0)
    };
}
export const TSSPacketReceipt = {
    typeUrl: "/band.tunnel.v1beta1.TSSPacketReceipt",
    encode(message, writer = BinaryWriter.create()) {
        if (message.signingId !== BigInt(0)) {
            writer.uint32(8).uint64(message.signingId);
        }
        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 = createBaseTSSPacketReceipt();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.signingId = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseTSSPacketReceipt();
        message.signingId = object.signingId !== undefined && object.signingId !== null ? BigInt(object.signingId.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseTSSPacketReceipt();
        if (object.signing_id !== undefined && object.signing_id !== null) {
            message.signingId = BigInt(object.signing_id);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.signing_id = message.signingId !== BigInt(0) ? message.signingId?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return TSSPacketReceipt.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return TSSPacketReceipt.decode(message.value);
    },
    toProto(message) {
        return TSSPacketReceipt.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.TSSPacketReceipt",
            value: TSSPacketReceipt.encode(message).finish()
        };
    }
};
function createBaseIBCRoute() {
    return {
        $typeUrl: "/band.tunnel.v1beta1.IBCRoute",
        channelId: ""
    };
}
export const IBCRoute = {
    typeUrl: "/band.tunnel.v1beta1.IBCRoute",
    encode(message, writer = BinaryWriter.create()) {
        if (message.channelId !== "") {
            writer.uint32(10).string(message.channelId);
        }
        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 = createBaseIBCRoute();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.channelId = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseIBCRoute();
        message.channelId = object.channelId ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseIBCRoute();
        if (object.channel_id !== undefined && object.channel_id !== null) {
            message.channelId = object.channel_id;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.channel_id = message.channelId === "" ? undefined : message.channelId;
        return obj;
    },
    fromAminoMsg(object) {
        return IBCRoute.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return IBCRoute.decode(message.value);
    },
    toProto(message) {
        return IBCRoute.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.IBCRoute",
            value: IBCRoute.encode(message).finish()
        };
    }
};
function createBaseIBCPacketReceipt() {
    return {
        $typeUrl: "/band.tunnel.v1beta1.IBCPacketReceipt",
        sequence: BigInt(0)
    };
}
export const IBCPacketReceipt = {
    typeUrl: "/band.tunnel.v1beta1.IBCPacketReceipt",
    encode(message, writer = BinaryWriter.create()) {
        if (message.sequence !== BigInt(0)) {
            writer.uint32(8).uint64(message.sequence);
        }
        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 = createBaseIBCPacketReceipt();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.sequence = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseIBCPacketReceipt();
        message.sequence = object.sequence !== undefined && object.sequence !== null ? BigInt(object.sequence.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseIBCPacketReceipt();
        if (object.sequence !== undefined && object.sequence !== null) {
            message.sequence = BigInt(object.sequence);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.sequence = message.sequence !== BigInt(0) ? message.sequence?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return IBCPacketReceipt.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return IBCPacketReceipt.decode(message.value);
    },
    toProto(message) {
        return IBCPacketReceipt.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.IBCPacketReceipt",
            value: IBCPacketReceipt.encode(message).finish()
        };
    }
};
function createBaseTunnelPricesPacketData() {
    return {
        tunnelId: BigInt(0),
        sequence: BigInt(0),
        prices: [],
        createdAt: BigInt(0)
    };
}
export const TunnelPricesPacketData = {
    typeUrl: "/band.tunnel.v1beta1.TunnelPricesPacketData",
    encode(message, writer = BinaryWriter.create()) {
        if (message.tunnelId !== BigInt(0)) {
            writer.uint32(8).uint64(message.tunnelId);
        }
        if (message.sequence !== BigInt(0)) {
            writer.uint32(16).uint64(message.sequence);
        }
        for (const v of message.prices) {
            Price.encode(v, writer.uint32(26).fork()).ldelim();
        }
        if (message.createdAt !== BigInt(0)) {
            writer.uint32(32).int64(message.createdAt);
        }
        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 = createBaseTunnelPricesPacketData();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tunnelId = reader.uint64();
                    break;
                case 2:
                    message.sequence = reader.uint64();
                    break;
                case 3:
                    message.prices.push(Price.decode(reader, reader.uint32()));
                    break;
                case 4:
                    message.createdAt = reader.int64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseTunnelPricesPacketData();
        message.tunnelId = object.tunnelId !== undefined && object.tunnelId !== null ? BigInt(object.tunnelId.toString()) : BigInt(0);
        message.sequence = object.sequence !== undefined && object.sequence !== null ? BigInt(object.sequence.toString()) : BigInt(0);
        message.prices = object.prices?.map(e => Price.fromPartial(e)) || [];
        message.createdAt = object.createdAt !== undefined && object.createdAt !== null ? BigInt(object.createdAt.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseTunnelPricesPacketData();
        if (object.tunnel_id !== undefined && object.tunnel_id !== null) {
            message.tunnelId = BigInt(object.tunnel_id);
        }
        if (object.sequence !== undefined && object.sequence !== null) {
            message.sequence = BigInt(object.sequence);
        }
        message.prices = object.prices?.map(e => Price.fromAmino(e)) || [];
        if (object.created_at !== undefined && object.created_at !== null) {
            message.createdAt = BigInt(object.created_at);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.tunnel_id = message.tunnelId !== BigInt(0) ? message.tunnelId?.toString() : undefined;
        obj.sequence = message.sequence !== BigInt(0) ? message.sequence?.toString() : undefined;
        if (message.prices) {
            obj.prices = message.prices.map(e => e ? Price.toAmino(e) : undefined);
        }
        else {
            obj.prices = message.prices;
        }
        obj.created_at = message.createdAt !== BigInt(0) ? message.createdAt?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return TunnelPricesPacketData.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return TunnelPricesPacketData.decode(message.value);
    },
    toProto(message) {
        return TunnelPricesPacketData.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.TunnelPricesPacketData",
            value: TunnelPricesPacketData.encode(message).finish()
        };
    }
};
function createBaseIBCHookRoute() {
    return {
        $typeUrl: "/band.tunnel.v1beta1.IBCHookRoute",
        channelId: "",
        destinationContractAddress: ""
    };
}
export const IBCHookRoute = {
    typeUrl: "/band.tunnel.v1beta1.IBCHookRoute",
    encode(message, writer = BinaryWriter.create()) {
        if (message.channelId !== "") {
            writer.uint32(10).string(message.channelId);
        }
        if (message.destinationContractAddress !== "") {
            writer.uint32(18).string(message.destinationContractAddress);
        }
        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 = createBaseIBCHookRoute();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.channelId = reader.string();
                    break;
                case 2:
                    message.destinationContractAddress = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseIBCHookRoute();
        message.channelId = object.channelId ?? "";
        message.destinationContractAddress = object.destinationContractAddress ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseIBCHookRoute();
        if (object.channel_id !== undefined && object.channel_id !== null) {
            message.channelId = object.channel_id;
        }
        if (object.destination_contract_address !== undefined && object.destination_contract_address !== null) {
            message.destinationContractAddress = object.destination_contract_address;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.channel_id = message.channelId === "" ? undefined : message.channelId;
        obj.destination_contract_address = message.destinationContractAddress === "" ? undefined : message.destinationContractAddress;
        return obj;
    },
    fromAminoMsg(object) {
        return IBCHookRoute.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return IBCHookRoute.decode(message.value);
    },
    toProto(message) {
        return IBCHookRoute.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.IBCHookRoute",
            value: IBCHookRoute.encode(message).finish()
        };
    }
};
function createBaseIBCHookPacketReceipt() {
    return {
        $typeUrl: "/band.tunnel.v1beta1.IBCHookPacketReceipt",
        sequence: BigInt(0)
    };
}
export const IBCHookPacketReceipt = {
    typeUrl: "/band.tunnel.v1beta1.IBCHookPacketReceipt",
    encode(message, writer = BinaryWriter.create()) {
        if (message.sequence !== BigInt(0)) {
            writer.uint32(8).uint64(message.sequence);
        }
        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 = createBaseIBCHookPacketReceipt();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.sequence = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseIBCHookPacketReceipt();
        message.sequence = object.sequence !== undefined && object.sequence !== null ? BigInt(object.sequence.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseIBCHookPacketReceipt();
        if (object.sequence !== undefined && object.sequence !== null) {
            message.sequence = BigInt(object.sequence);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.sequence = message.sequence !== BigInt(0) ? message.sequence?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return IBCHookPacketReceipt.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return IBCHookPacketReceipt.decode(message.value);
    },
    toProto(message) {
        return IBCHookPacketReceipt.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.IBCHookPacketReceipt",
            value: IBCHookPacketReceipt.encode(message).finish()
        };
    }
};
function createBaseIBCHookMemo() {
    return {
        wasm: IBCHookMemo_Payload.fromPartial({})
    };
}
export const IBCHookMemo = {
    typeUrl: "/band.tunnel.v1beta1.IBCHookMemo",
    encode(message, writer = BinaryWriter.create()) {
        if (message.wasm !== undefined) {
            IBCHookMemo_Payload.encode(message.wasm, writer.uint32(10).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 = createBaseIBCHookMemo();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.wasm = IBCHookMemo_Payload.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseIBCHookMemo();
        message.wasm = object.wasm !== undefined && object.wasm !== null ? IBCHookMemo_Payload.fromPartial(object.wasm) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseIBCHookMemo();
        if (object.wasm !== undefined && object.wasm !== null) {
            message.wasm = IBCHookMemo_Payload.fromAmino(object.wasm);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.wasm = message.wasm ? IBCHookMemo_Payload.toAmino(message.wasm) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return IBCHookMemo.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return IBCHookMemo.decode(message.value);
    },
    toProto(message) {
        return IBCHookMemo.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.IBCHookMemo",
            value: IBCHookMemo.encode(message).finish()
        };
    }
};
function createBaseIBCHookMemo_Payload() {
    return {
        contract: "",
        msg: IBCHookMemo_Payload_Msg.fromPartial({})
    };
}
export const IBCHookMemo_Payload = {
    typeUrl: "/band.tunnel.v1beta1.Payload",
    encode(message, writer = BinaryWriter.create()) {
        if (message.contract !== "") {
            writer.uint32(10).string(message.contract);
        }
        if (message.msg !== undefined) {
            IBCHookMemo_Payload_Msg.encode(message.msg, writer.uint32(18).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 = createBaseIBCHookMemo_Payload();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.contract = reader.string();
                    break;
                case 2:
                    message.msg = IBCHookMemo_Payload_Msg.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseIBCHookMemo_Payload();
        message.contract = object.contract ?? "";
        message.msg = object.msg !== undefined && object.msg !== null ? IBCHookMemo_Payload_Msg.fromPartial(object.msg) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseIBCHookMemo_Payload();
        if (object.contract !== undefined && object.contract !== null) {
            message.contract = object.contract;
        }
        if (object.msg !== undefined && object.msg !== null) {
            message.msg = IBCHookMemo_Payload_Msg.fromAmino(object.msg);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.contract = message.contract === "" ? undefined : message.contract;
        obj.msg = message.msg ? IBCHookMemo_Payload_Msg.toAmino(message.msg) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return IBCHookMemo_Payload.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return IBCHookMemo_Payload.decode(message.value);
    },
    toProto(message) {
        return IBCHookMemo_Payload.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.Payload",
            value: IBCHookMemo_Payload.encode(message).finish()
        };
    }
};
function createBaseIBCHookMemo_Payload_Msg() {
    return {
        receivePacket: IBCHookMemo_Payload_Msg_ReceivePacket.fromPartial({})
    };
}
export const IBCHookMemo_Payload_Msg = {
    typeUrl: "/band.tunnel.v1beta1.Msg",
    encode(message, writer = BinaryWriter.create()) {
        if (message.receivePacket !== undefined) {
            IBCHookMemo_Payload_Msg_ReceivePacket.encode(message.receivePacket, writer.uint32(10).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 = createBaseIBCHookMemo_Payload_Msg();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.receivePacket = IBCHookMemo_Payload_Msg_ReceivePacket.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseIBCHookMemo_Payload_Msg();
        message.receivePacket = object.receivePacket !== undefined && object.receivePacket !== null ? IBCHookMemo_Payload_Msg_ReceivePacket.fromPartial(object.receivePacket) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseIBCHookMemo_Payload_Msg();
        if (object.receive_packet !== undefined && object.receive_packet !== null) {
            message.receivePacket = IBCHookMemo_Payload_Msg_ReceivePacket.fromAmino(object.receive_packet);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.receive_packet = message.receivePacket ? IBCHookMemo_Payload_Msg_ReceivePacket.toAmino(message.receivePacket) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return IBCHookMemo_Payload_Msg.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return IBCHookMemo_Payload_Msg.decode(message.value);
    },
    toProto(message) {
        return IBCHookMemo_Payload_Msg.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.Msg",
            value: IBCHookMemo_Payload_Msg.encode(message).finish()
        };
    }
};
function createBaseIBCHookMemo_Payload_Msg_ReceivePacket() {
    return {
        packet: TunnelPricesPacketData.fromPartial({})
    };
}
export const IBCHookMemo_Payload_Msg_ReceivePacket = {
    typeUrl: "/band.tunnel.v1beta1.ReceivePacket",
    encode(message, writer = BinaryWriter.create()) {
        if (message.packet !== undefined) {
            TunnelPricesPacketData.encode(message.packet, writer.uint32(10).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 = createBaseIBCHookMemo_Payload_Msg_ReceivePacket();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.packet = TunnelPricesPacketData.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseIBCHookMemo_Payload_Msg_ReceivePacket();
        message.packet = object.packet !== undefined && object.packet !== null ? TunnelPricesPacketData.fromPartial(object.packet) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseIBCHookMemo_Payload_Msg_ReceivePacket();
        if (object.packet !== undefined && object.packet !== null) {
            message.packet = TunnelPricesPacketData.fromAmino(object.packet);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.packet = message.packet ? TunnelPricesPacketData.toAmino(message.packet) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return IBCHookMemo_Payload_Msg_ReceivePacket.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return IBCHookMemo_Payload_Msg_ReceivePacket.decode(message.value);
    },
    toProto(message) {
        return IBCHookMemo_Payload_Msg_ReceivePacket.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.ReceivePacket",
            value: IBCHookMemo_Payload_Msg_ReceivePacket.encode(message).finish()
        };
    }
};
function createBaseRouterRoute() {
    return {
        $typeUrl: "/band.tunnel.v1beta1.RouterRoute",
        destinationChainId: "",
        destinationContractAddress: "",
        destinationGasLimit: BigInt(0)
    };
}
export const RouterRoute = {
    typeUrl: "/band.tunnel.v1beta1.RouterRoute",
    encode(message, writer = BinaryWriter.create()) {
        if (message.destinationChainId !== "") {
            writer.uint32(10).string(message.destinationChainId);
        }
        if (message.destinationContractAddress !== "") {
            writer.uint32(18).string(message.destinationContractAddress);
        }
        if (message.destinationGasLimit !== BigInt(0)) {
            writer.uint32(24).uint64(message.destinationGasLimit);
        }
        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 = createBaseRouterRoute();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.destinationChainId = reader.string();
                    break;
                case 2:
                    message.destinationContractAddress = reader.string();
                    break;
                case 3:
                    message.destinationGasLimit = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseRouterRoute();
        message.destinationChainId = object.destinationChainId ?? "";
        message.destinationContractAddress = object.destinationContractAddress ?? "";
        message.destinationGasLimit = object.destinationGasLimit !== undefined && object.destinationGasLimit !== null ? BigInt(object.destinationGasLimit.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseRouterRoute();
        if (object.destination_chain_id !== undefined && object.destination_chain_id !== null) {
            message.destinationChainId = object.destination_chain_id;
        }
        if (object.destination_contract_address !== undefined && object.destination_contract_address !== null) {
            message.destinationContractAddress = object.destination_contract_address;
        }
        if (object.destination_gas_limit !== undefined && object.destination_gas_limit !== null) {
            message.destinationGasLimit = BigInt(object.destination_gas_limit);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.destination_chain_id = message.destinationChainId === "" ? undefined : message.destinationChainId;
        obj.destination_contract_address = message.destinationContractAddress === "" ? undefined : message.destinationContractAddress;
        obj.destination_gas_limit = message.destinationGasLimit !== BigInt(0) ? message.destinationGasLimit?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return RouterRoute.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return RouterRoute.decode(message.value);
    },
    toProto(message) {
        return RouterRoute.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.RouterRoute",
            value: RouterRoute.encode(message).finish()
        };
    }
};
function createBaseRouterPacketReceipt() {
    return {
        $typeUrl: "/band.tunnel.v1beta1.RouterPacketReceipt",
        sequence: BigInt(0)
    };
}
export const RouterPacketReceipt = {
    typeUrl: "/band.tunnel.v1beta1.RouterPacketReceipt",
    encode(message, writer = BinaryWriter.create()) {
        if (message.sequence !== BigInt(0)) {
            writer.uint32(8).uint64(message.sequence);
        }
        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 = createBaseRouterPacketReceipt();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.sequence = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseRouterPacketReceipt();
        message.sequence = object.sequence !== undefined && object.sequence !== null ? BigInt(object.sequence.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseRouterPacketReceipt();
        if (object.sequence !== undefined && object.sequence !== null) {
            message.sequence = BigInt(object.sequence);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.sequence = message.sequence !== BigInt(0) ? message.sequence?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return RouterPacketReceipt.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return RouterPacketReceipt.decode(message.value);
    },
    toProto(message) {
        return RouterPacketReceipt.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.RouterPacketReceipt",
            value: RouterPacketReceipt.encode(message).finish()
        };
    }
};
function createBaseRouterMemo() {
    return {
        wasm: RouterMemo_Payload.fromPartial({})
    };
}
export const RouterMemo = {
    typeUrl: "/band.tunnel.v1beta1.RouterMemo",
    encode(message, writer = BinaryWriter.create()) {
        if (message.wasm !== undefined) {
            RouterMemo_Payload.encode(message.wasm, writer.uint32(10).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 = createBaseRouterMemo();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.wasm = RouterMemo_Payload.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseRouterMemo();
        message.wasm = object.wasm !== undefined && object.wasm !== null ? RouterMemo_Payload.fromPartial(object.wasm) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseRouterMemo();
        if (object.wasm !== undefined && object.wasm !== null) {
            message.wasm = RouterMemo_Payload.fromAmino(object.wasm);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.wasm = message.wasm ? RouterMemo_Payload.toAmino(message.wasm) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return RouterMemo.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return RouterMemo.decode(message.value);
    },
    toProto(message) {
        return RouterMemo.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.RouterMemo",
            value: RouterMemo.encode(message).finish()
        };
    }
};
function createBaseRouterMemo_Payload() {
    return {
        contract: "",
        msg: RouterMemo_Payload_Msg.fromPartial({})
    };
}
export const RouterMemo_Payload = {
    typeUrl: "/band.tunnel.v1beta1.Payload",
    encode(message, writer = BinaryWriter.create()) {
        if (message.contract !== "") {
            writer.uint32(10).string(message.contract);
        }
        if (message.msg !== undefined) {
            RouterMemo_Payload_Msg.encode(message.msg, writer.uint32(18).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 = createBaseRouterMemo_Payload();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.contract = reader.string();
                    break;
                case 2:
                    message.msg = RouterMemo_Payload_Msg.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseRouterMemo_Payload();
        message.contract = object.contract ?? "";
        message.msg = object.msg !== undefined && object.msg !== null ? RouterMemo_Payload_Msg.fromPartial(object.msg) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseRouterMemo_Payload();
        if (object.contract !== undefined && object.contract !== null) {
            message.contract = object.contract;
        }
        if (object.msg !== undefined && object.msg !== null) {
            message.msg = RouterMemo_Payload_Msg.fromAmino(object.msg);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.contract = message.contract === "" ? undefined : message.contract;
        obj.msg = message.msg ? RouterMemo_Payload_Msg.toAmino(message.msg) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return RouterMemo_Payload.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return RouterMemo_Payload.decode(message.value);
    },
    toProto(message) {
        return RouterMemo_Payload.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.Payload",
            value: RouterMemo_Payload.encode(message).finish()
        };
    }
};
function createBaseRouterMemo_Payload_Msg() {
    return {
        receiveBandData: RouterMemo_Payload_Msg_ReceiveBandDataArgs.fromPartial({})
    };
}
export const RouterMemo_Payload_Msg = {
    typeUrl: "/band.tunnel.v1beta1.Msg",
    encode(message, writer = BinaryWriter.create()) {
        if (message.receiveBandData !== undefined) {
            RouterMemo_Payload_Msg_ReceiveBandDataArgs.encode(message.receiveBandData, writer.uint32(10).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 = createBaseRouterMemo_Payload_Msg();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.receiveBandData = RouterMemo_Payload_Msg_ReceiveBandDataArgs.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseRouterMemo_Payload_Msg();
        message.receiveBandData = object.receiveBandData !== undefined && object.receiveBandData !== null ? RouterMemo_Payload_Msg_ReceiveBandDataArgs.fromPartial(object.receiveBandData) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseRouterMemo_Payload_Msg();
        if (object.receive_band_data !== undefined && object.receive_band_data !== null) {
            message.receiveBandData = RouterMemo_Payload_Msg_ReceiveBandDataArgs.fromAmino(object.receive_band_data);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.receive_band_data = message.receiveBandData ? RouterMemo_Payload_Msg_ReceiveBandDataArgs.toAmino(message.receiveBandData) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return RouterMemo_Payload_Msg.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return RouterMemo_Payload_Msg.decode(message.value);
    },
    toProto(message) {
        return RouterMemo_Payload_Msg.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.Msg",
            value: RouterMemo_Payload_Msg.encode(message).finish()
        };
    }
};
function createBaseRouterMemo_Payload_Msg_ReceiveBandDataArgs() {
    return {
        destChainId: "",
        destContractAddress: "",
        gasLimit: BigInt(0),
        payload: ""
    };
}
export const RouterMemo_Payload_Msg_ReceiveBandDataArgs = {
    typeUrl: "/band.tunnel.v1beta1.ReceiveBandDataArgs",
    encode(message, writer = BinaryWriter.create()) {
        if (message.destChainId !== "") {
            writer.uint32(10).string(message.destChainId);
        }
        if (message.destContractAddress !== "") {
            writer.uint32(18).string(message.destContractAddress);
        }
        if (message.gasLimit !== BigInt(0)) {
            writer.uint32(24).uint64(message.gasLimit);
        }
        if (message.payload !== "") {
            writer.uint32(34).string(message.payload);
        }
        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 = createBaseRouterMemo_Payload_Msg_ReceiveBandDataArgs();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.destChainId = reader.string();
                    break;
                case 2:
                    message.destContractAddress = reader.string();
                    break;
                case 3:
                    message.gasLimit = reader.uint64();
                    break;
                case 4:
                    message.payload = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseRouterMemo_Payload_Msg_ReceiveBandDataArgs();
        message.destChainId = object.destChainId ?? "";
        message.destContractAddress = object.destContractAddress ?? "";
        message.gasLimit = object.gasLimit !== undefined && object.gasLimit !== null ? BigInt(object.gasLimit.toString()) : BigInt(0);
        message.payload = object.payload ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseRouterMemo_Payload_Msg_ReceiveBandDataArgs();
        if (object.dest_chain_id !== undefined && object.dest_chain_id !== null) {
            message.destChainId = object.dest_chain_id;
        }
        if (object.dest_contract_address !== undefined && object.dest_contract_address !== null) {
            message.destContractAddress = object.dest_contract_address;
        }
        if (object.gas_limit !== undefined && object.gas_limit !== null) {
            message.gasLimit = BigInt(object.gas_limit);
        }
        if (object.payload !== undefined && object.payload !== null) {
            message.payload = object.payload;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.dest_chain_id = message.destChainId === "" ? undefined : message.destChainId;
        obj.dest_contract_address = message.destContractAddress === "" ? undefined : message.destContractAddress;
        obj.gas_limit = message.gasLimit !== BigInt(0) ? message.gasLimit?.toString() : undefined;
        obj.payload = message.payload === "" ? undefined : message.payload;
        return obj;
    },
    fromAminoMsg(object) {
        return RouterMemo_Payload_Msg_ReceiveBandDataArgs.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return RouterMemo_Payload_Msg_ReceiveBandDataArgs.decode(message.value);
    },
    toProto(message) {
        return RouterMemo_Payload_Msg_ReceiveBandDataArgs.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.ReceiveBandDataArgs",
            value: RouterMemo_Payload_Msg_ReceiveBandDataArgs.encode(message).finish()
        };
    }
};
function createBaseAxelarRoute() {
    return {
        $typeUrl: "/band.tunnel.v1beta1.AxelarRoute",
        destinationChainId: "",
        destinationContractAddress: "",
        fee: Coin.fromPartial({})
    };
}
export const AxelarRoute = {
    typeUrl: "/band.tunnel.v1beta1.AxelarRoute",
    encode(message, writer = BinaryWriter.create()) {
        if (message.destinationChainId !== "") {
            writer.uint32(10).string(message.destinationChainId);
        }
        if (message.destinationContractAddress !== "") {
            writer.uint32(18).string(message.destinationContractAddress);
        }
        if (message.fee !== undefined) {
            Coin.encode(message.fee, 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 = createBaseAxelarRoute();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.destinationChainId = reader.string();
                    break;
                case 2:
                    message.destinationContractAddress = reader.string();
                    break;
                case 3:
                    message.fee = Coin.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseAxelarRoute();
        message.destinationChainId = object.destinationChainId ?? "";
        message.destinationContractAddress = object.destinationContractAddress ?? "";
        message.fee = object.fee !== undefined && object.fee !== null ? Coin.fromPartial(object.fee) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseAxelarRoute();
        if (object.destination_chain_id !== undefined && object.destination_chain_id !== null) {
            message.destinationChainId = object.destination_chain_id;
        }
        if (object.destination_contract_address !== undefined && object.destination_contract_address !== null) {
            message.destinationContractAddress = object.destination_contract_address;
        }
        if (object.fee !== undefined && object.fee !== null) {
            message.fee = Coin.fromAmino(object.fee);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.destination_chain_id = message.destinationChainId === "" ? undefined : message.destinationChainId;
        obj.destination_contract_address = message.destinationContractAddress === "" ? undefined : message.destinationContractAddress;
        obj.fee = message.fee ? Coin.toAmino(message.fee) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return AxelarRoute.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return AxelarRoute.decode(message.value);
    },
    toProto(message) {
        return AxelarRoute.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.AxelarRoute",
            value: AxelarRoute.encode(message).finish()
        };
    }
};
function createBaseAxelarPacketReceipt() {
    return {
        $typeUrl: "/band.tunnel.v1beta1.AxelarPacketReceipt",
        sequence: BigInt(0)
    };
}
export const AxelarPacketReceipt = {
    typeUrl: "/band.tunnel.v1beta1.AxelarPacketReceipt",
    encode(message, writer = BinaryWriter.create()) {
        if (message.sequence !== BigInt(0)) {
            writer.uint32(8).uint64(message.sequence);
        }
        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 = createBaseAxelarPacketReceipt();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1: