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

TypeScript library for Cosmos SDK and BandChain

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.PacketReceiptI_ToAmino = exports.PacketReceiptI_FromAmino = exports.PacketReceiptI_InterfaceDecoder = exports.RouteI_ToAmino = exports.RouteI_FromAmino = exports.RouteI_InterfaceDecoder = exports.TunnelSignatureOrder = exports.SignalDeviation = exports.Deposit = exports.Packet = exports.TotalFees = exports.LatestPrices = exports.Tunnel = void 0;
//@ts-nocheck
const any_1 = require("../../../google/protobuf/any");
const coin_1 = require("../../../cosmos/base/v1beta1/coin");
const feeds_1 = require("../../feeds/v1beta1/feeds");
const route_1 = require("./route");
const binary_1 = require("../../../binary");
function createBaseTunnel() {
    return {
        id: BigInt(0),
        sequence: BigInt(0),
        route: undefined,
        feePayer: "",
        signalDeviations: [],
        interval: BigInt(0),
        totalDeposit: [],
        isActive: false,
        createdAt: BigInt(0),
        creator: ""
    };
}
exports.Tunnel = {
    typeUrl: "/band.tunnel.v1beta1.Tunnel",
    encode(message, writer = binary_1.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_1.Any.encode(message.route, writer.uint32(26).fork()).ldelim();
        }
        if (message.feePayer !== "") {
            writer.uint32(34).string(message.feePayer);
        }
        for (const v of message.signalDeviations) {
            exports.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_1.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 binary_1.BinaryReader ? input : new binary_1.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 = (0, exports.RouteI_InterfaceDecoder)(reader);
                    break;
                case 4:
                    message.feePayer = reader.string();
                    break;
                case 5:
                    message.signalDeviations.push(exports.SignalDeviation.decode(reader, reader.uint32()));
                    break;
                case 6:
                    message.interval = reader.uint64();
                    break;
                case 7:
                    message.totalDeposit.push(coin_1.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_1.Any.fromPartial(object.route) : undefined;
        message.feePayer = object.feePayer ?? "";
        message.signalDeviations = object.signalDeviations?.map(e => exports.SignalDeviation.fromPartial(e)) || [];
        message.interval = object.interval !== undefined && object.interval !== null ? BigInt(object.interval.toString()) : BigInt(0);
        message.totalDeposit = object.totalDeposit?.map(e => coin_1.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 = (0, exports.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 => exports.SignalDeviation.fromAmino(e)) || [];
        if (object.interval !== undefined && object.interval !== null) {
            message.interval = BigInt(object.interval);
        }
        message.totalDeposit = object.total_deposit?.map(e => coin_1.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 ? (0, exports.RouteI_ToAmino)(message.route) : undefined;
        obj.fee_payer = message.feePayer === "" ? undefined : message.feePayer;
        if (message.signalDeviations) {
            obj.signal_deviations = message.signalDeviations.map(e => e ? exports.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_1.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 exports.Tunnel.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.Tunnel.decode(message.value);
    },
    toProto(message) {
        return exports.Tunnel.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.Tunnel",
            value: exports.Tunnel.encode(message).finish()
        };
    }
};
function createBaseLatestPrices() {
    return {
        tunnelId: BigInt(0),
        prices: [],
        lastInterval: BigInt(0)
    };
}
exports.LatestPrices = {
    typeUrl: "/band.tunnel.v1beta1.LatestPrices",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.tunnelId !== BigInt(0)) {
            writer.uint32(8).uint64(message.tunnelId);
        }
        for (const v of message.prices) {
            feeds_1.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 binary_1.BinaryReader ? input : new binary_1.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(feeds_1.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 => feeds_1.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 => feeds_1.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 ? feeds_1.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 exports.LatestPrices.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.LatestPrices.decode(message.value);
    },
    toProto(message) {
        return exports.LatestPrices.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.LatestPrices",
            value: exports.LatestPrices.encode(message).finish()
        };
    }
};
function createBaseTotalFees() {
    return {
        totalBasePacketFee: []
    };
}
exports.TotalFees = {
    typeUrl: "/band.tunnel.v1beta1.TotalFees",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        for (const v of message.totalBasePacketFee) {
            coin_1.Coin.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.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_1.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_1.Coin.fromPartial(e)) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseTotalFees();
        message.totalBasePacketFee = object.total_base_packet_fee?.map(e => coin_1.Coin.fromAmino(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.totalBasePacketFee) {
            obj.total_base_packet_fee = message.totalBasePacketFee.map(e => e ? coin_1.Coin.toAmino(e) : undefined);
        }
        else {
            obj.total_base_packet_fee = message.totalBasePacketFee;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return exports.TotalFees.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.TotalFees.decode(message.value);
    },
    toProto(message) {
        return exports.TotalFees.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.TotalFees",
            value: exports.TotalFees.encode(message).finish()
        };
    }
};
function createBasePacket() {
    return {
        tunnelId: BigInt(0),
        sequence: BigInt(0),
        prices: [],
        receipt: undefined,
        createdAt: BigInt(0)
    };
}
exports.Packet = {
    typeUrl: "/band.tunnel.v1beta1.Packet",
    encode(message, writer = binary_1.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) {
            feeds_1.Price.encode(v, writer.uint32(26).fork()).ldelim();
        }
        if (message.receipt !== undefined) {
            any_1.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 binary_1.BinaryReader ? input : new binary_1.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(feeds_1.Price.decode(reader, reader.uint32()));
                    break;
                case 4:
                    message.receipt = (0, exports.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 => feeds_1.Price.fromPartial(e)) || [];
        message.receipt = object.receipt !== undefined && object.receipt !== null ? any_1.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 => feeds_1.Price.fromAmino(e)) || [];
        if (object.receipt !== undefined && object.receipt !== null) {
            message.receipt = (0, exports.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 ? feeds_1.Price.toAmino(e) : undefined);
        }
        else {
            obj.prices = message.prices;
        }
        obj.receipt = message.receipt ? (0, exports.PacketReceiptI_ToAmino)(message.receipt) : undefined;
        obj.created_at = message.createdAt !== BigInt(0) ? message.createdAt?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.Packet.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.Packet.decode(message.value);
    },
    toProto(message) {
        return exports.Packet.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.Packet",
            value: exports.Packet.encode(message).finish()
        };
    }
};
function createBaseDeposit() {
    return {
        tunnelId: BigInt(0),
        depositor: "",
        amount: []
    };
}
exports.Deposit = {
    typeUrl: "/band.tunnel.v1beta1.Deposit",
    encode(message, writer = binary_1.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_1.Coin.encode(v, writer.uint32(26).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.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_1.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_1.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_1.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_1.Coin.toAmino(e) : undefined);
        }
        else {
            obj.amount = message.amount;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return exports.Deposit.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.Deposit.decode(message.value);
    },
    toProto(message) {
        return exports.Deposit.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.Deposit",
            value: exports.Deposit.encode(message).finish()
        };
    }
};
function createBaseSignalDeviation() {
    return {
        signalId: "",
        softDeviationBps: BigInt(0),
        hardDeviationBps: BigInt(0)
    };
}
exports.SignalDeviation = {
    typeUrl: "/band.tunnel.v1beta1.SignalDeviation",
    encode(message, writer = binary_1.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 binary_1.BinaryReader ? input : new binary_1.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 exports.SignalDeviation.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.SignalDeviation.decode(message.value);
    },
    toProto(message) {
        return exports.SignalDeviation.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.SignalDeviation",
            value: exports.SignalDeviation.encode(message).finish()
        };
    }
};
function createBaseTunnelSignatureOrder() {
    return {
        sequence: BigInt(0),
        prices: [],
        createdAt: BigInt(0),
        encoder: 0
    };
}
exports.TunnelSignatureOrder = {
    typeUrl: "/band.tunnel.v1beta1.TunnelSignatureOrder",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.sequence !== BigInt(0)) {
            writer.uint32(8).uint64(message.sequence);
        }
        for (const v of message.prices) {
            feeds_1.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 binary_1.BinaryReader ? input : new binary_1.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(feeds_1.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 => feeds_1.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 => feeds_1.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 ? feeds_1.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 exports.TunnelSignatureOrder.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.TunnelSignatureOrder.decode(message.value);
    },
    toProto(message) {
        return exports.TunnelSignatureOrder.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.tunnel.v1beta1.TunnelSignatureOrder",
            value: exports.TunnelSignatureOrder.encode(message).finish()
        };
    }
};
const RouteI_InterfaceDecoder = (input) => {
    const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
    const data = any_1.Any.decode(reader, reader.uint32());
    switch (data.typeUrl) {
        case "/band.tunnel.v1beta1.TSSRoute":
            return route_1.TSSRoute.decode(data.value);
        case "/band.tunnel.v1beta1.IBCRoute":
            return route_1.IBCRoute.decode(data.value);
        case "/band.tunnel.v1beta1.IBCHookRoute":
            return route_1.IBCHookRoute.decode(data.value);
        case "/band.tunnel.v1beta1.RouterRoute":
            return route_1.RouterRoute.decode(data.value);
        case "/band.tunnel.v1beta1.AxelarRoute":
            return route_1.AxelarRoute.decode(data.value);
        default:
            return data;
    }
};
exports.RouteI_InterfaceDecoder = RouteI_InterfaceDecoder;
const RouteI_FromAmino = (content) => {
    switch (content.type) {
        case "/band.tunnel.v1beta1.TSSRoute":
            return any_1.Any.fromPartial({
                typeUrl: "/band.tunnel.v1beta1.TSSRoute",
                value: route_1.TSSRoute.encode(route_1.TSSRoute.fromPartial(route_1.TSSRoute.fromAmino(content.value))).finish()
            });
        case "/band.tunnel.v1beta1.IBCRoute":
            return any_1.Any.fromPartial({
                typeUrl: "/band.tunnel.v1beta1.IBCRoute",
                value: route_1.IBCRoute.encode(route_1.IBCRoute.fromPartial(route_1.IBCRoute.fromAmino(content.value))).finish()
            });
        case "/band.tunnel.v1beta1.IBCHookRoute":
            return any_1.Any.fromPartial({
                typeUrl: "/band.tunnel.v1beta1.IBCHookRoute",
                value: route_1.IBCHookRoute.encode(route_1.IBCHookRoute.fromPartial(route_1.IBCHookRoute.fromAmino(content.value))).finish()
            });
        case "/band.tunnel.v1beta1.RouterRoute":
            return any_1.Any.fromPartial({
                typeUrl: "/band.tunnel.v1beta1.RouterRoute",
                value: route_1.RouterRoute.encode(route_1.RouterRoute.fromPartial(route_1.RouterRoute.fromAmino(content.value))).finish()
            });
        case "/band.tunnel.v1beta1.AxelarRoute":
            return any_1.Any.fromPartial({
                typeUrl: "/band.tunnel.v1beta1.AxelarRoute",
                value: route_1.AxelarRoute.encode(route_1.AxelarRoute.fromPartial(route_1.AxelarRoute.fromAmino(content.value))).finish()
            });
        default:
            return any_1.Any.fromAmino(content);
    }
};
exports.RouteI_FromAmino = RouteI_FromAmino;
const RouteI_ToAmino = (content) => {
    switch (content.typeUrl) {
        case "/band.tunnel.v1beta1.TSSRoute":
            return {
                type: "/band.tunnel.v1beta1.TSSRoute",
                value: route_1.TSSRoute.toAmino(route_1.TSSRoute.decode(content.value, undefined))
            };
        case "/band.tunnel.v1beta1.IBCRoute":
            return {
                type: "/band.tunnel.v1beta1.IBCRoute",
                value: route_1.IBCRoute.toAmino(route_1.IBCRoute.decode(content.value, undefined))
            };
        case "/band.tunnel.v1beta1.IBCHookRoute":
            return {
                type: "/band.tunnel.v1beta1.IBCHookRoute",
                value: route_1.IBCHookRoute.toAmino(route_1.IBCHookRoute.decode(content.value, undefined))
            };
        case "/band.tunnel.v1beta1.RouterRoute":
            return {
                type: "/band.tunnel.v1beta1.RouterRoute",
                value: route_1.RouterRoute.toAmino(route_1.RouterRoute.decode(content.value, undefined))
            };
        case "/band.tunnel.v1beta1.AxelarRoute":
            return {
                type: "/band.tunnel.v1beta1.AxelarRoute",
                value: route_1.AxelarRoute.toAmino(route_1.AxelarRoute.decode(content.value, undefined))
            };
        default:
            return any_1.Any.toAmino(content);
    }
};
exports.RouteI_ToAmino = RouteI_ToAmino;
const PacketReceiptI_InterfaceDecoder = (input) => {
    const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
    const data = any_1.Any.decode(reader, reader.uint32());
    switch (data.typeUrl) {
        case "/band.tunnel.v1beta1.TSSPacketReceipt":
            return route_1.TSSPacketReceipt.decode(data.value);
        case "/band.tunnel.v1beta1.IBCPacketReceipt":
            return route_1.IBCPacketReceipt.decode(data.value);
        case "/band.tunnel.v1beta1.RouterPacketReceipt":
            return route_1.RouterPacketReceipt.decode(data.value);
        case "/band.tunnel.v1beta1.AxelarPacketReceipt":
            return route_1.AxelarPacketReceipt.decode(data.value);
        default:
            return data;
    }
};
exports.PacketReceiptI_InterfaceDecoder = PacketReceiptI_InterfaceDecoder;
const PacketReceiptI_FromAmino = (content) => {
    switch (content.type) {
        case "/band.tunnel.v1beta1.TSSPacketReceipt":
            return any_1.Any.fromPartial({
                typeUrl: "/band.tunnel.v1beta1.TSSPacketReceipt",
                value: route_1.TSSPacketReceipt.encode(route_1.TSSPacketReceipt.fromPartial(route_1.TSSPacketReceipt.fromAmino(content.value))).finish()
            });
        case "/band.tunnel.v1beta1.IBCPacketReceipt":
            return any_1.Any.fromPartial({
                typeUrl: "/band.tunnel.v1beta1.IBCPacketReceipt",
                value: route_1.IBCPacketReceipt.encode(route_1.IBCPacketReceipt.fromPartial(route_1.IBCPacketReceipt.fromAmino(content.value))).finish()
            });
        case "/band.tunnel.v1beta1.RouterPacketReceipt":
            return any_1.Any.fromPartial({
                typeUrl: "/band.tunnel.v1beta1.RouterPacketReceipt",
                value: route_1.RouterPacketReceipt.encode(route_1.RouterPacketReceipt.fromPartial(route_1.RouterPacketReceipt.fromAmino(content.value))).finish()
            });
        case "/band.tunnel.v1beta1.AxelarPacketReceipt":
            return any_1.Any.fromPartial({
                typeUrl: "/band.tunnel.v1beta1.AxelarPacketReceipt",
                value: route_1.AxelarPacketReceipt.encode(route_1.AxelarPacketReceipt.fromPartial(route_1.AxelarPacketReceipt.fromAmino(content.value))).finish()
            });
        default:
            return any_1.Any.fromAmino(content);
    }
};
exports.PacketReceiptI_FromAmino = PacketReceiptI_FromAmino;
const PacketReceiptI_ToAmino = (content) => {
    switch (content.typeUrl) {
        case "/band.tunnel.v1beta1.TSSPacketReceipt":
            return {
                type: "/band.tunnel.v1beta1.TSSPacketReceipt",
                value: route_1.TSSPacketReceipt.toAmino(route_1.TSSPacketReceipt.decode(content.value, undefined))
            };
        case "/band.tunnel.v1beta1.IBCPacketReceipt":
            return {
                type: "/band.tunnel.v1beta1.IBCPacketReceipt",
                value: route_1.IBCPacketReceipt.toAmino(route_1.IBCPacketReceipt.decode(content.value, undefined))
            };
        case "/band.tunnel.v1beta1.RouterPacketReceipt":
            return {
                type: "/band.tunnel.v1beta1.RouterPacketReceipt",
                value: route_1.RouterPacketReceipt.toAmino(route_1.RouterPacketReceipt.decode(content.value, undefined))
            };
        case "/band.tunnel.v1beta1.AxelarPacketReceipt":
            return {
                type: "/band.tunnel.v1beta1.AxelarPacketReceipt",
                value: route_1.AxelarPacketReceipt.toAmino(route_1.AxelarPacketReceipt.decode(content.value, undefined))
            };
        default:
            return any_1.Any.toAmino(content);
    }
};
exports.PacketReceiptI_ToAmino = PacketReceiptI_ToAmino;