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

TypeScript library for Cosmos SDK and BandChain

//@ts-nocheck
import { Any } from "../../../google/protobuf/any";
import { Coin } from "../../../cosmos/base/v1beta1/coin";
import { Price } from "../../feeds/v1beta1/feeds";
import { TSSRoute, IBCRoute, IBCHookRoute, RouterRoute, AxelarRoute, TSSPacketReceipt, IBCPacketReceipt, RouterPacketReceipt, AxelarPacketReceipt } from "./route";
import { BinaryReader, BinaryWriter } from "../../../binary";
function createBaseTunnel() {
    return {
        id: BigInt(0),
        sequence: BigInt(0),
        route: undefined,
        feePayer: "",
        signalDeviations: [],
        interval: BigInt(0),
        totalDeposit: [],
        isActive: false,
        createdAt: BigInt(0),
        creator: ""
    };
}
export const Tunnel = {
    typeUrl: "/band.tunnel.v1beta1.Tunnel",
    encode(message, writer = BinaryWriter.create()) {
        if (message.id !== BigInt(0)) {
            writer.uint32(8).uint64(message.id);
        }
        if (message.sequence !== BigInt(0)) {
            writer.uint32(16).uint64(message.sequence);
        }
        if (message.route !== undefined) {
            Any.encode(message.route, writer.uint32(26).fork()).ldelim();
        }
        if (message.feePayer !== "") {
            writer.uint32(34).string(message.feePayer);
        }
        for (const v of message.signalDeviations) {
            SignalDeviation.encode(v, writer.uint32(42).fork()).ldelim();
        }
        if (message.interval !== BigInt(0)) {
            writer.uint32(48).uint64(message.interval);
        }
        for (const v of message.totalDeposit) {
            Coin.encode(v, writer.uint32(58).fork()).ldelim();
        }
        if (message.isActive === true) {
            writer.uint32(64).bool(message.isActive);
        }
        if (message.createdAt !== BigInt(0)) {
            writer.uint32(72).int64(message.createdAt);
        }
        if (message.creator !== "") {
            writer.uint32(82).string(message.creator);
        }
        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 = createBaseTunnel();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.id = reader.uint64();
                    break;
                case 2:
                    message.sequence = reader.uint64();
                    break;
                case 3:
                    message.route = RouteI_InterfaceDecoder(reader);
                    break;
                case 4:
                    message.feePayer = reader.string();
                    break;
                case 5:
                    message.signalDeviations.push(SignalDeviation.decode(reader, reader.uint32()));
                    break;
                case 6:
                    message.interval = reader.uint64();
                    break;
                case 7:
                    message.totalDeposit.push(Coin.decode(reader, reader.uint32()));
                    break;
                case 8:
                    message.isActive = reader.bool();
                    break;
                case 9:
                    message.createdAt = reader.int64();
                    break;
                case 10:
                    message.creator = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseTunnel();
        message.id = object.id !== undefined && object.id !== null ? BigInt(object.id.toString()) : BigInt(0);
        message.sequence = object.sequence !== undefined && object.sequence !== null ? BigInt(object.sequence.toString()) : BigInt(0);
        message.route = object.route !== undefined && object.route !== null ? Any.fromPartial(object.route) : undefined;
        message.feePayer = object.feePayer ?? "";
        message.signalDeviations = object.signalDeviations?.map(e => SignalDeviation.fromPartial(e)) || [];
        message.interval = object.interval !== undefined && object.interval !== null ? BigInt(object.interval.toString()) : BigInt(0);
        message.totalDeposit = object.totalDeposit?.map(e => Coin.fromPartial(e)) || [];
        message.isActive = object.isActive ?? false;
        message.createdAt = object.createdAt !== undefined && object.createdAt !== null ? BigInt(object.createdAt.toString()) : BigInt(0);
        message.creator = object.creator ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseTunnel();
        if (object.id !== undefined && object.id !== null) {
            message.id = BigInt(object.id);
        }
        if (object.sequence !== undefined && object.sequence !== null) {
            message.sequence = BigInt(object.sequence);
        }
        if (object.route !== undefined && object.route !== null) {
            message.route = RouteI_FromAmino(object.route);
        }
        if (object.fee_payer !== undefined && object.fee_payer !== null) {
            message.feePayer = object.fee_payer;
        }
        message.signalDeviations = object.signal_deviations?.map(e => SignalDeviation.fromAmino(e)) || [];
        if (object.interval !== undefined && object.interval !== null) {
            message.interval = BigInt(object.interval);
        }
        message.totalDeposit = object.total_deposit?.map(e => Coin.fromAmino(e)) || [];
        if (object.is_active !== undefined && object.is_active !== null) {
            message.isActive = object.is_active;
        }
        if (object.created_at !== undefined && object.created_at !== null) {
            message.createdAt = BigInt(object.created_at);
        }
        if (object.creator !== undefined && object.creator !== null) {
            message.creator = object.creator;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.id = message.id !== BigInt(0) ? message.id?.toString() : undefined;
        obj.sequence = message.sequence !== BigInt(0) ? message.sequence?.toString() : undefined;
        obj.route = message.route ? RouteI_ToAmino(message.route) : undefined;
        obj.fee_payer = message.feePayer === "" ? undefined : message.feePayer;
        if (message.signalDeviations) {
            obj.signal_deviations = message.signalDeviations.map(e => e ? SignalDeviation.toAmino(e) : undefined);
        }
        else {
            obj.signal_deviations = message.signalDeviations;
        }
        obj.interval = message.interval !== BigInt(0) ? message.interval?.toString() : undefined;
        if (message.totalDeposit) {
            obj.total_deposit = message.totalDeposit.map(e => e ? Coin.toAmino(e) : undefined);
        }
        else {
            obj.total_deposit = message.totalDeposit;
        }
        obj.is_active = message.isActive === false ? undefined : message.isActive;
        obj.created_at = message.createdAt !== BigInt(0) ? message.createdAt?.toString() : undefined;
        obj.creator = message.creator === "" ? undefined : message.creator;
        return obj;
    },
    fromAminoMsg(object) {
        return Tunnel.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return Tunnel.decode(message.value);
    },
    toProto(message) {
        return Tunnel.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.Tunnel",
            value: Tunnel.encode(message).finish()
        };
    }
};
function createBaseLatestPrices() {
    return {
        tunnelId: BigInt(0),
        prices: [],
        lastInterval: BigInt(0)
    };
}
export const LatestPrices = {
    typeUrl: "/band.tunnel.v1beta1.LatestPrices",
    encode(message, writer = BinaryWriter.create()) {
        if (message.tunnelId !== BigInt(0)) {
            writer.uint32(8).uint64(message.tunnelId);
        }
        for (const v of message.prices) {
            Price.encode(v, writer.uint32(18).fork()).ldelim();
        }
        if (message.lastInterval !== BigInt(0)) {
            writer.uint32(24).int64(message.lastInterval);
        }
        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 = createBaseLatestPrices();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tunnelId = reader.uint64();
                    break;
                case 2:
                    message.prices.push(Price.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.lastInterval = reader.int64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseLatestPrices();
        message.tunnelId = object.tunnelId !== undefined && object.tunnelId !== null ? BigInt(object.tunnelId.toString()) : BigInt(0);
        message.prices = object.prices?.map(e => Price.fromPartial(e)) || [];
        message.lastInterval = object.lastInterval !== undefined && object.lastInterval !== null ? BigInt(object.lastInterval.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseLatestPrices();
        if (object.tunnel_id !== undefined && object.tunnel_id !== null) {
            message.tunnelId = BigInt(object.tunnel_id);
        }
        message.prices = object.prices?.map(e => Price.fromAmino(e)) || [];
        if (object.last_interval !== undefined && object.last_interval !== null) {
            message.lastInterval = BigInt(object.last_interval);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.tunnel_id = message.tunnelId !== BigInt(0) ? message.tunnelId?.toString() : undefined;
        if (message.prices) {
            obj.prices = message.prices.map(e => e ? Price.toAmino(e) : undefined);
        }
        else {
            obj.prices = message.prices;
        }
        obj.last_interval = message.lastInterval !== BigInt(0) ? message.lastInterval?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return LatestPrices.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return LatestPrices.decode(message.value);
    },
    toProto(message) {
        return LatestPrices.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.LatestPrices",
            value: LatestPrices.encode(message).finish()
        };
    }
};
function createBaseTotalFees() {
    return {
        totalBasePacketFee: []
    };
}
export const TotalFees = {
    typeUrl: "/band.tunnel.v1beta1.TotalFees",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.totalBasePacketFee) {
            Coin.encode(v, 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 = createBaseTotalFees();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.totalBasePacketFee.push(Coin.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseTotalFees();
        message.totalBasePacketFee = object.totalBasePacketFee?.map(e => Coin.fromPartial(e)) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseTotalFees();
        message.totalBasePacketFee = object.total_base_packet_fee?.map(e => Coin.fromAmino(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.totalBasePacketFee) {
            obj.total_base_packet_fee = message.totalBasePacketFee.map(e => e ? Coin.toAmino(e) : undefined);
        }
        else {
            obj.total_base_packet_fee = message.totalBasePacketFee;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return TotalFees.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return TotalFees.decode(message.value);
    },
    toProto(message) {
        return TotalFees.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.TotalFees",
            value: TotalFees.encode(message).finish()
        };
    }
};
function createBasePacket() {
    return {
        tunnelId: BigInt(0),
        sequence: BigInt(0),
        prices: [],
        receipt: undefined,
        createdAt: BigInt(0)
    };
}
export const Packet = {
    typeUrl: "/band.tunnel.v1beta1.Packet",
    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.receipt !== undefined) {
            Any.encode(message.receipt, writer.uint32(34).fork()).ldelim();
        }
        if (message.createdAt !== BigInt(0)) {
            writer.uint32(40).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 = createBasePacket();
        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.receipt = PacketReceiptI_InterfaceDecoder(reader);
                    break;
                case 5:
                    message.createdAt = reader.int64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBasePacket();
        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.receipt = object.receipt !== undefined && object.receipt !== null ? Any.fromPartial(object.receipt) : undefined;
        message.createdAt = object.createdAt !== undefined && object.createdAt !== null ? BigInt(object.createdAt.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBasePacket();
        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.receipt !== undefined && object.receipt !== null) {
            message.receipt = PacketReceiptI_FromAmino(object.receipt);
        }
        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.receipt = message.receipt ? PacketReceiptI_ToAmino(message.receipt) : undefined;
        obj.created_at = message.createdAt !== BigInt(0) ? message.createdAt?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return Packet.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return Packet.decode(message.value);
    },
    toProto(message) {
        return Packet.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.Packet",
            value: Packet.encode(message).finish()
        };
    }
};
function createBaseDeposit() {
    return {
        tunnelId: BigInt(0),
        depositor: "",
        amount: []
    };
}
export const Deposit = {
    typeUrl: "/band.tunnel.v1beta1.Deposit",
    encode(message, writer = BinaryWriter.create()) {
        if (message.tunnelId !== BigInt(0)) {
            writer.uint32(8).uint64(message.tunnelId);
        }
        if (message.depositor !== "") {
            writer.uint32(18).string(message.depositor);
        }
        for (const v of message.amount) {
            Coin.encode(v, 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 = createBaseDeposit();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tunnelId = reader.uint64();
                    break;
                case 2:
                    message.depositor = reader.string();
                    break;
                case 3:
                    message.amount.push(Coin.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseDeposit();
        message.tunnelId = object.tunnelId !== undefined && object.tunnelId !== null ? BigInt(object.tunnelId.toString()) : BigInt(0);
        message.depositor = object.depositor ?? "";
        message.amount = object.amount?.map(e => Coin.fromPartial(e)) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseDeposit();
        if (object.tunnel_id !== undefined && object.tunnel_id !== null) {
            message.tunnelId = BigInt(object.tunnel_id);
        }
        if (object.depositor !== undefined && object.depositor !== null) {
            message.depositor = object.depositor;
        }
        message.amount = object.amount?.map(e => Coin.fromAmino(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.tunnel_id = message.tunnelId !== BigInt(0) ? message.tunnelId?.toString() : undefined;
        obj.depositor = message.depositor === "" ? undefined : message.depositor;
        if (message.amount) {
            obj.amount = message.amount.map(e => e ? Coin.toAmino(e) : undefined);
        }
        else {
            obj.amount = message.amount;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return Deposit.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return Deposit.decode(message.value);
    },
    toProto(message) {
        return Deposit.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.Deposit",
            value: Deposit.encode(message).finish()
        };
    }
};
function createBaseSignalDeviation() {
    return {
        signalId: "",
        softDeviationBps: BigInt(0),
        hardDeviationBps: BigInt(0)
    };
}
export const SignalDeviation = {
    typeUrl: "/band.tunnel.v1beta1.SignalDeviation",
    encode(message, writer = BinaryWriter.create()) {
        if (message.signalId !== "") {
            writer.uint32(10).string(message.signalId);
        }
        if (message.softDeviationBps !== BigInt(0)) {
            writer.uint32(16).uint64(message.softDeviationBps);
        }
        if (message.hardDeviationBps !== BigInt(0)) {
            writer.uint32(24).uint64(message.hardDeviationBps);
        }
        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 = createBaseSignalDeviation();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.signalId = reader.string();
                    break;
                case 2:
                    message.softDeviationBps = reader.uint64();
                    break;
                case 3:
                    message.hardDeviationBps = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseSignalDeviation();
        message.signalId = object.signalId ?? "";
        message.softDeviationBps = object.softDeviationBps !== undefined && object.softDeviationBps !== null ? BigInt(object.softDeviationBps.toString()) : BigInt(0);
        message.hardDeviationBps = object.hardDeviationBps !== undefined && object.hardDeviationBps !== null ? BigInt(object.hardDeviationBps.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseSignalDeviation();
        if (object.signal_id !== undefined && object.signal_id !== null) {
            message.signalId = object.signal_id;
        }
        if (object.soft_deviation_bps !== undefined && object.soft_deviation_bps !== null) {
            message.softDeviationBps = BigInt(object.soft_deviation_bps);
        }
        if (object.hard_deviation_bps !== undefined && object.hard_deviation_bps !== null) {
            message.hardDeviationBps = BigInt(object.hard_deviation_bps);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.signal_id = message.signalId === "" ? undefined : message.signalId;
        obj.soft_deviation_bps = message.softDeviationBps !== BigInt(0) ? message.softDeviationBps?.toString() : undefined;
        obj.hard_deviation_bps = message.hardDeviationBps !== BigInt(0) ? message.hardDeviationBps?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return SignalDeviation.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return SignalDeviation.decode(message.value);
    },
    toProto(message) {
        return SignalDeviation.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.SignalDeviation",
            value: SignalDeviation.encode(message).finish()
        };
    }
};
function createBaseTunnelSignatureOrder() {
    return {
        sequence: BigInt(0),
        prices: [],
        createdAt: BigInt(0),
        encoder: 0
    };
}
export const TunnelSignatureOrder = {
    typeUrl: "/band.tunnel.v1beta1.TunnelSignatureOrder",
    encode(message, writer = BinaryWriter.create()) {
        if (message.sequence !== BigInt(0)) {
            writer.uint32(8).uint64(message.sequence);
        }
        for (const v of message.prices) {
            Price.encode(v, writer.uint32(18).fork()).ldelim();
        }
        if (message.createdAt !== BigInt(0)) {
            writer.uint32(24).int64(message.createdAt);
        }
        if (message.encoder !== 0) {
            writer.uint32(32).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 = createBaseTunnelSignatureOrder();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.sequence = reader.uint64();
                    break;
                case 2:
                    message.prices.push(Price.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.createdAt = reader.int64();
                    break;
                case 4:
                    message.encoder = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseTunnelSignatureOrder();
        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);
        message.encoder = object.encoder ?? 0;
        return message;
    },
    fromAmino(object) {
        const message = createBaseTunnelSignatureOrder();
        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);
        }
        if (object.encoder !== undefined && object.encoder !== null) {
            message.encoder = object.encoder;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        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;
        obj.encoder = message.encoder === 0 ? undefined : message.encoder;
        return obj;
    },
    fromAminoMsg(object) {
        return TunnelSignatureOrder.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return TunnelSignatureOrder.decode(message.value);
    },
    toProto(message) {
        return TunnelSignatureOrder.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.TunnelSignatureOrder",
            value: TunnelSignatureOrder.encode(message).finish()
        };
    }
};
export const RouteI_InterfaceDecoder = (input) => {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const data = Any.decode(reader, reader.uint32());
    switch (data.typeUrl) {
        case "/band.tunnel.v1beta1.TSSRoute":
            return TSSRoute.decode(data.value);
        case "/band.tunnel.v1beta1.IBCRoute":
            return IBCRoute.decode(data.value);
        case "/band.tunnel.v1beta1.IBCHookRoute":
            return IBCHookRoute.decode(data.value);
        case "/band.tunnel.v1beta1.RouterRoute":
            return RouterRoute.decode(data.value);
        case "/band.tunnel.v1beta1.AxelarRoute":
            return AxelarRoute.decode(data.value);
        default:
            return data;
    }
};
export const RouteI_FromAmino = (content) => {
    switch (content.type) {
        case "/band.tunnel.v1beta1.TSSRoute":
            return Any.fromPartial({
                typeUrl: "/band.tunnel.v1beta1.TSSRoute",
                value: TSSRoute.encode(TSSRoute.fromPartial(TSSRoute.fromAmino(content.value))).finish()
            });
        case "/band.tunnel.v1beta1.IBCRoute":
            return Any.fromPartial({
                typeUrl: "/band.tunnel.v1beta1.IBCRoute",
                value: IBCRoute.encode(IBCRoute.fromPartial(IBCRoute.fromAmino(content.value))).finish()
            });
        case "/band.tunnel.v1beta1.IBCHookRoute":
            return Any.fromPartial({
                typeUrl: "/band.tunnel.v1beta1.IBCHookRoute",
                value: IBCHookRoute.encode(IBCHookRoute.fromPartial(IBCHookRoute.fromAmino(content.value))).finish()
            });
        case "/band.tunnel.v1beta1.RouterRoute":
            return Any.fromPartial({
                typeUrl: "/band.tunnel.v1beta1.RouterRoute",
                value: RouterRoute.encode(RouterRoute.fromPartial(RouterRoute.fromAmino(content.value))).finish()
            });
        case "/band.tunnel.v1beta1.AxelarRoute":
            return Any.fromPartial({
                typeUrl: "/band.tunnel.v1beta1.AxelarRoute",
                value: AxelarRoute.encode(AxelarRoute.fromPartial(AxelarRoute.fromAmino(content.value))).finish()
            });
        default:
            return Any.fromAmino(content);
    }
};
export const RouteI_ToAmino = (content) => {
    switch (content.typeUrl) {
        case "/band.tunnel.v1beta1.TSSRoute":
            return {
                type: "/band.tunnel.v1beta1.TSSRoute",
                value: TSSRoute.toAmino(TSSRoute.decode(content.value, undefined))
            };
        case "/band.tunnel.v1beta1.IBCRoute":
            return {
                type: "/band.tunnel.v1beta1.IBCRoute",
                value: IBCRoute.toAmino(IBCRoute.decode(content.value, undefined))
            };
        case "/band.tunnel.v1beta1.IBCHookRoute":
            return {
                type: "/band.tunnel.v1beta1.IBCHookRoute",
                value: IBCHookRoute.toAmino(IBCHookRoute.decode(content.value, undefined))
            };
        case "/band.tunnel.v1beta1.RouterRoute":
            return {
                type: "/band.tunnel.v1beta1.RouterRoute",
                value: RouterRoute.toAmino(RouterRoute.decode(content.value, undefined))
            };
        case "/band.tunnel.v1beta1.AxelarRoute":
            return {
                type: "/band.tunnel.v1beta1.AxelarRoute",
                value: AxelarRoute.toAmino(AxelarRoute.decode(content.value, undefined))
            };
        default:
            return Any.toAmino(content);
    }
};
export const PacketReceiptI_InterfaceDecoder = (input) => {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const data = Any.decode(reader, reader.uint32());
    switch (data.typeUrl) {
        case "/band.tunnel.v1beta1.TSSPacketReceipt":
            return TSSPacketReceipt.decode(data.value);
        case "/band.tunnel.v1beta1.IBCPacketReceipt":
            return IBCPacketReceipt.decode(data.value);
        case "/band.tunnel.v1beta1.RouterPacketReceipt":
            return RouterPacketReceipt.decode(data.value);
        case "/band.tunnel.v1beta1.AxelarPacketReceipt":
            return AxelarPacketReceipt.decode(data.value);
        default:
            return data;
    }
};
export const PacketReceiptI_FromAmino = (content) => {
    switch (content.type) {
        case "/band.tunnel.v1beta1.TSSPacketReceipt":
            return Any.fromPartial({
                typeUrl: "/band.tunnel.v1beta1.TSSPacketReceipt",
                value: TSSPacketReceipt.encode(TSSPacketReceipt.fromPartial(TSSPacketReceipt.fromAmino(content.value))).finish()
            });
        case "/band.tunnel.v1beta1.IBCPacketReceipt":
            return Any.fromPartial({
                typeUrl: "/band.tunnel.v1beta1.IBCPacketReceipt",
                value: IBCPacketReceipt.encode(IBCPacketReceipt.fromPartial(IBCPacketReceipt.fromAmino(content.value))).finish()
            });
        case "/band.tunnel.v1beta1.RouterPacketReceipt":
            return Any.fromPartial({
                typeUrl: "/band.tunnel.v1beta1.RouterPacketReceipt",
                value: RouterPacketReceipt.encode(RouterPacketReceipt.fromPartial(RouterPacketReceipt.fromAmino(content.value))).finish()
            });
        case "/band.tunnel.v1beta1.AxelarPacketReceipt":
            return Any.fromPartial({
                typeUrl: "/band.tunnel.v1beta1.AxelarPacketReceipt",
                value: AxelarPacketReceipt.encode(AxelarPacketReceipt.fromPartial(AxelarPacketReceipt.fromAmino(content.value))).finish()
            });
        default:
            return Any.fromAmino(content);
    }
};
export const PacketReceiptI_ToAmino = (content) => {
    switch (content.typeUrl) {
        case "/band.tunnel.v1beta1.TSSPacketReceipt":
            return {
                type: "/band.tunnel.v1beta1.TSSPacketReceipt",
                value: TSSPacketReceipt.toAmino(TSSPacketReceipt.decode(content.value, undefined))
            };
        case "/band.tunnel.v1beta1.IBCPacketReceipt":
            return {
                type: "/band.tunnel.v1beta1.IBCPacketReceipt",
                value: IBCPacketReceipt.toAmino(IBCPacketReceipt.decode(content.value, undefined))
            };
        case "/band.tunnel.v1beta1.RouterPacketReceipt":
            return {
                type: "/band.tunnel.v1beta1.RouterPacketReceipt",
                value: RouterPacketReceipt.toAmino(RouterPacketReceipt.decode(content.value, undefined))
            };
        case "/band.tunnel.v1beta1.AxelarPacketReceipt":
            return {
                type: "/band.tunnel.v1beta1.AxelarPacketReceipt",
                value: AxelarPacketReceipt.toAmino(AxelarPacketReceipt.decode(content.value, undefined))
            };
        default:
            return Any.toAmino(content);
    }
};