//! Crypto-bank currency symbols and pairs primitives.

#[macro_use]
extern crate failure;
#[macro_use]
extern crate serde_derive;
extern crate serde;

use std::fmt;
use std::str::FromStr;

use serde::de::{self, Deserialize, Deserializer, Visitor};
use serde::ser::{Serialize, Serializer};

/// Crypto market currency error type.
#[derive(Debug, Fail)]
pub enum Error {
    /// Invalid pair error.
    #[fail(display = "{} is not a valid currency pair.", _0)]
    InvalidPair(String),
}

/// Currency symbol.
#[derive(Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord, Clone, Hash, Debug)]
pub enum Currency {
    Custom(String),
    Ada,
    Adx,
    Ae,
    Agi,
    Aion,
    Algo,
    Amb,
    Ankr,
    Appc,
    Ardr,
    Ark,
    Arn,
    Arpa,
    Ast,
    Atom,
    Band,
    Bat,
    Bcc,
    Bcd,
    Bch,
    Bchabc,
    Bchsv,
    Bcn,
    Bcpt,
    Beam,
    Bgbp,
    Blz,
    Bnb,
    Bnt,
    Bqx,
    Brd,
    Btc,
    Btcb,
    Btg,
    Bts,
    Btt,
    Busd,
    Cdt,
    Celr,
    Chat,
    Chz,
    Cloak,
    Cmt,
    Cnd,
    Cocos,
    Cos,
    Ctxc,
    Cvc,
    Dash,
    Data,
    Dcr,
    Dent,
    Dgb,
    Dgd,
    Dlt,
    Dnt,
    Dock,
    Doge,
    Dusk,
    Edo,
    Elf,
    Eng,
    Enj,
    Eos,
    Erd,
    Etc,
    Eth,
    Evx,
    Fct,
    Fet,
    Foam,
    Ftm,
    Ftt,
    Fuel,
    Fun,
    Gas,
    Gnt,
    Go,
    Grin,
    Grs,
    Gto,
    Gvt,
    Gxs,
    Hbar,
    Hc,
    Hot,
    Hsr,
    Icn,
    Icx,
    Ins,
    Iost,
    Iota,
    Iotx,
    Kava,
    Key,
    Kmd,
    Knc,
    Lend,
    Link,
    Loom,
    Lpt,
    Lrc,
    Lsk,
    Ltc,
    Lun,
    Maid,
    Mana,
    Matic,
    Mco,
    Mda,
    Mft,
    Mith,
    Mod,
    Mth,
    Mtl,
    Nano,
    Nas,
    Nav,
    Ncash,
    Nebl,
    Neo,
    Ngn,
    Nkn,
    Nmr,
    Npxs,
    Nuls,
    Nxs,
    Nxt,
    Oax,
    Omg,
    Omni,
    One,
    Ong,
    Ont,
    Ost,
    Pax,
    Perl,
    Phb,
    Phx,
    Pivx,
    Poa,
    Poe,
    Poly,
    Powr,
    Ppt,
    Qkc,
    Qlc,
    Qsp,
    Qtum,
    Rcn,
    Rdn,
    Ren,
    Rep,
    Req,
    Rlc,
    Rpx,
    Rub,
    Rvn,
    Salt,
    Sc,
    Sky,
    Sngls,
    Snm,
    Snt,
    Steem,
    Storj,
    Storm,
    Str,
    Strat,
    Stx,
    Sub,
    Sys,
    Tfuel,
    Theta,
    Tnb,
    Tnt,
    Tomo,
    Trig,
    Troy,
    Trx,
    Try,
    Tusd,
    Tusdb,
    Usdc,
    Usds,
    Usdsb,
    Usdt,
    Ven,
    Vet,
    Via,
    Vib,
    Vibe,
    Vite,
    Vtc,
    Wabi,
    Wan,
    Waves,
    Win,
    Wings,
    Wpr,
    Wtc,
    Xem,
    Xlm,
    Xmr,
    Xpm,
    Xrp,
    Xtz,
    Xvg,
    Xzc,
    Yoyo,
    Zec,
    Zen,
    Zil,
    Zrx,
}

impl Currency {
    pub fn as_str(&self) -> &str {
        match self {
            Currency::Custom(ref s) => s,
            &Currency::Ada => "ADA",
            &Currency::Adx => "ADX",
            &Currency::Ae => "AE",
            &Currency::Agi => "AGI",
            &Currency::Aion => "AION",
            &Currency::Algo => "ALGO",
            &Currency::Amb => "AMB",
            &Currency::Ankr => "ANKR",
            &Currency::Appc => "APPC",
            &Currency::Ardr => "ARDR",
            &Currency::Ark => "ARK",
            &Currency::Arn => "ARN",
            &Currency::Arpa => "ARPA",
            &Currency::Ast => "AST",
            &Currency::Atom => "ATOM",
            &Currency::Band => "BAND",
            &Currency::Bat => "BAT",
            &Currency::Bcc => "BCC",
            &Currency::Bcd => "BCD",
            &Currency::Bch => "BCH",
            &Currency::Bchabc => "BCHABC",
            &Currency::Bchsv => "BCHSV",
            &Currency::Bcn => "BCN",
            &Currency::Bcpt => "BCPT",
            &Currency::Beam => "BEAM",
            &Currency::Bgbp => "BGBP",
            &Currency::Blz => "BLZ",
            &Currency::Bnb => "BNB",
            &Currency::Bnt => "BNT",
            &Currency::Bqx => "BQX",
            &Currency::Brd => "BRD",
            &Currency::Btc => "BTC",
            &Currency::Btcb => "BTCB",
            &Currency::Btg => "BTG",
            &Currency::Bts => "BTS",
            &Currency::Btt => "BTT",
            &Currency::Busd => "BUSD",
            &Currency::Cdt => "CDT",
            &Currency::Celr => "CELR",
            &Currency::Chat => "CHAT",
            &Currency::Chz => "CHZ",
            &Currency::Cloak => "CLOAK",
            &Currency::Cmt => "CMT",
            &Currency::Cnd => "CND",
            &Currency::Cocos => "COCOS",
            &Currency::Cos => "COS",
            &Currency::Ctxc => "CTXC",
            &Currency::Cvc => "CVC",
            &Currency::Dash => "DASH",
            &Currency::Data => "DATA",
            &Currency::Dcr => "DCR",
            &Currency::Dent => "DENT",
            &Currency::Dgb => "DGB",
            &Currency::Dgd => "DGD",
            &Currency::Dlt => "DLT",
            &Currency::Dnt => "DNT",
            &Currency::Dock => "DOCK",
            &Currency::Doge => "DOGE",
            &Currency::Dusk => "DUSK",
            &Currency::Edo => "EDO",
            &Currency::Elf => "ELF",
            &Currency::Eng => "ENG",
            &Currency::Enj => "ENJ",
            &Currency::Eos => "EOS",
            &Currency::Erd => "ERD",
            &Currency::Etc => "ETC",
            &Currency::Eth => "ETH",
            &Currency::Evx => "EVX",
            &Currency::Fct => "FCT",
            &Currency::Fet => "FET",
            &Currency::Foam => "FOAM",
            &Currency::Ftm => "FTM",
            &Currency::Ftt => "FTT",
            &Currency::Fuel => "FUEL",
            &Currency::Fun => "FUN",
            &Currency::Gas => "GAS",
            &Currency::Gnt => "GNT",
            &Currency::Go => "GO",
            &Currency::Grin => "GRIN",
            &Currency::Grs => "GRS",
            &Currency::Gto => "GTO",
            &Currency::Gvt => "GVT",
            &Currency::Gxs => "GXS",
            &Currency::Hbar => "HBAR",
            &Currency::Hc => "HC",
            &Currency::Hot => "HOT",
            &Currency::Hsr => "HSR",
            &Currency::Icn => "ICN",
            &Currency::Icx => "ICX",
            &Currency::Ins => "INS",
            &Currency::Iost => "IOST",
            &Currency::Iota => "IOTA",
            &Currency::Iotx => "IOTX",
            &Currency::Kava => "KAVA",
            &Currency::Key => "KEY",
            &Currency::Kmd => "KMD",
            &Currency::Knc => "KNC",
            &Currency::Lend => "LEND",
            &Currency::Link => "LINK",
            &Currency::Loom => "LOOM",
            &Currency::Lpt => "LPT",
            &Currency::Lrc => "LRC",
            &Currency::Lsk => "LSK",
            &Currency::Ltc => "LTC",
            &Currency::Lun => "LUN",
            &Currency::Maid => "MAID",
            &Currency::Mana => "MANA",
            &Currency::Matic => "MATIC",
            &Currency::Mco => "MCO",
            &Currency::Mda => "MDA",
            &Currency::Mft => "MFT",
            &Currency::Mith => "MITH",
            &Currency::Mod => "MOD",
            &Currency::Mth => "MTH",
            &Currency::Mtl => "MTL",
            &Currency::Nano => "NANO",
            &Currency::Nas => "NAS",
            &Currency::Nav => "NAV",
            &Currency::Ncash => "NCASH",
            &Currency::Nebl => "NEBL",
            &Currency::Neo => "NEO",
            &Currency::Ngn => "NGN",
            &Currency::Nkn => "NKN",
            &Currency::Nmr => "NMR",
            &Currency::Npxs => "NPXS",
            &Currency::Nuls => "NULS",
            &Currency::Nxs => "NXS",
            &Currency::Nxt => "NXT",
            &Currency::Oax => "OAX",
            &Currency::Omg => "OMG",
            &Currency::Omni => "OMNI",
            &Currency::One => "ONE",
            &Currency::Ong => "ONG",
            &Currency::Ont => "ONT",
            &Currency::Ost => "OST",
            &Currency::Pax => "PAX",
            &Currency::Perl => "PERL",
            &Currency::Phb => "PHB",
            &Currency::Phx => "PHX",
            &Currency::Pivx => "PIVX",
            &Currency::Poa => "POA",
            &Currency::Poe => "POE",
            &Currency::Poly => "POLY",
            &Currency::Powr => "POWR",
            &Currency::Ppt => "PPT",
            &Currency::Qkc => "QKC",
            &Currency::Qlc => "QLC",
            &Currency::Qsp => "QSP",
            &Currency::Qtum => "QTUM",
            &Currency::Rcn => "RCN",
            &Currency::Rdn => "RDN",
            &Currency::Ren => "REN",
            &Currency::Rep => "REP",
            &Currency::Req => "REQ",
            &Currency::Rlc => "RLC",
            &Currency::Rpx => "RPX",
            &Currency::Rub => "RUB",
            &Currency::Rvn => "RVN",
            &Currency::Salt => "SALT",
            &Currency::Sc => "SC",
            &Currency::Sky => "SKY",
            &Currency::Sngls => "SNGLS",
            &Currency::Snm => "SNM",
            &Currency::Snt => "SNT",
            &Currency::Steem => "STEEM",
            &Currency::Storj => "STORJ",
            &Currency::Storm => "STORM",
            &Currency::Str => "STR",
            &Currency::Strat => "STRAT",
            &Currency::Stx => "STX",
            &Currency::Sub => "SUB",
            &Currency::Sys => "SYS",
            &Currency::Tfuel => "TFUEL",
            &Currency::Theta => "THETA",
            &Currency::Tnb => "TNB",
            &Currency::Tnt => "TNT",
            &Currency::Tomo => "TOMO",
            &Currency::Trig => "TRIG",
            &Currency::Troy => "TROY",
            &Currency::Trx => "TRX",
            &Currency::Try => "TRY",
            &Currency::Tusd => "TUSD",
            &Currency::Tusdb => "TUSDB",
            &Currency::Usdc => "USDC",
            &Currency::Usds => "USDS",
            &Currency::Usdsb => "USDSB",
            &Currency::Usdt => "USDT",
            &Currency::Ven => "VEN",
            &Currency::Vet => "VET",
            &Currency::Via => "VIA",
            &Currency::Vib => "VIB",
            &Currency::Vibe => "VIBE",
            &Currency::Vite => "VITE",
            &Currency::Vtc => "VTC",
            &Currency::Wabi => "WABI",
            &Currency::Wan => "WAN",
            &Currency::Waves => "WAVES",
            &Currency::Win => "WIN",
            &Currency::Wings => "WINGS",
            &Currency::Wpr => "WPR",
            &Currency::Wtc => "WTC",
            &Currency::Xem => "XEM",
            &Currency::Xlm => "XLM",
            &Currency::Xmr => "XMR",
            &Currency::Xpm => "XPM",
            &Currency::Xrp => "XRP",
            &Currency::Xtz => "XTZ",
            &Currency::Xvg => "XVG",
            &Currency::Xzc => "XZC",
            &Currency::Yoyo => "YOYO",
            &Currency::Zec => "ZEC",
            &Currency::Zen => "ZEN",
            &Currency::Zil => "ZIL",
            &Currency::Zrx => "ZRX",
        }
    }
}

impl ::std::fmt::Display for Currency {
    fn fmt(&self, f: &mut fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl From<&str> for Currency {
    fn from(symbol: &str) -> Self {
        match symbol {
            "ADA" => Currency::Ada,
            "ADX" => Currency::Adx,
            "AE" => Currency::Ae,
            "AGI" => Currency::Agi,
            "AION" => Currency::Aion,
            "ALGO" => Currency::Algo,
            "AMB" => Currency::Amb,
            "ANKR" => Currency::Ankr,
            "APPC" => Currency::Appc,
            "ARDR" => Currency::Ardr,
            "ARK" => Currency::Ark,
            "ARN" => Currency::Arn,
            "ARPA" => Currency::Arpa,
            "AST" => Currency::Ast,
            "ATOM" => Currency::Atom,
            "BAND" => Currency::Band,
            "BAT" => Currency::Bat,
            "BCC" => Currency::Bcc,
            "BCD" => Currency::Bcd,
            "BCH" => Currency::Bch,
            "BCHABC" => Currency::Bchabc,
            "BCHSV" => Currency::Bchsv,
            "BCN" => Currency::Bcn,
            "BCPT" => Currency::Bcpt,
            "BEAM" => Currency::Beam,
            "BGBP" => Currency::Bgbp,
            "BLZ" => Currency::Blz,
            "BNB" => Currency::Bnb,
            "BNT" => Currency::Bnt,
            "BQX" => Currency::Bqx,
            "BRD" => Currency::Brd,
            "BTC" => Currency::Btc,
            "BTCB" => Currency::Btcb,
            "BTG" => Currency::Btg,
            "BTS" => Currency::Bts,
            "BTT" => Currency::Btt,
            "BUSD" => Currency::Busd,
            "CDT" => Currency::Cdt,
            "CELR" => Currency::Celr,
            "CHAT" => Currency::Chat,
            "CHZ" => Currency::Chz,
            "CLOAK" => Currency::Cloak,
            "CMT" => Currency::Cmt,
            "CND" => Currency::Cnd,
            "COCOS" => Currency::Cocos,
            "COS" => Currency::Cos,
            "CTXC" => Currency::Ctxc,
            "CVC" => Currency::Cvc,
            "DASH" => Currency::Dash,
            "DATA" => Currency::Data,
            "DCR" => Currency::Dcr,
            "DENT" => Currency::Dent,
            "DGB" => Currency::Dgb,
            "DGD" => Currency::Dgd,
            "DLT" => Currency::Dlt,
            "DNT" => Currency::Dnt,
            "DOCK" => Currency::Dock,
            "DOGE" => Currency::Doge,
            "DUSK" => Currency::Dusk,
            "EDO" => Currency::Edo,
            "ELF" => Currency::Elf,
            "ENG" => Currency::Eng,
            "ENJ" => Currency::Enj,
            "EOS" => Currency::Eos,
            "ERD" => Currency::Erd,
            "ETC" => Currency::Etc,
            "ETH" => Currency::Eth,
            "EVX" => Currency::Evx,
            "FCT" => Currency::Fct,
            "FET" => Currency::Fet,
            "FOAM" => Currency::Foam,
            "FTM" => Currency::Ftm,
            "FTT" => Currency::Ftt,
            "FUEL" => Currency::Fuel,
            "FUN" => Currency::Fun,
            "GAS" => Currency::Gas,
            "GNT" => Currency::Gnt,
            "GO" => Currency::Go,
            "GRIN" => Currency::Grin,
            "GRS" => Currency::Grs,
            "GTO" => Currency::Gto,
            "GVT" => Currency::Gvt,
            "GXS" => Currency::Gxs,
            "HBAR" => Currency::Hbar,
            "HC" => Currency::Hc,
            "HOT" => Currency::Hot,
            "HSR" => Currency::Hsr,
            "ICN" => Currency::Icn,
            "ICX" => Currency::Icx,
            "INS" => Currency::Ins,
            "IOST" => Currency::Iost,
            "IOTA" => Currency::Iota,
            "IOTX" => Currency::Iotx,
            "KAVA" => Currency::Kava,
            "KEY" => Currency::Key,
            "KMD" => Currency::Kmd,
            "KNC" => Currency::Knc,
            "LEND" => Currency::Lend,
            "LINK" => Currency::Link,
            "LOOM" => Currency::Loom,
            "LPT" => Currency::Lpt,
            "LRC" => Currency::Lrc,
            "LSK" => Currency::Lsk,
            "LTC" => Currency::Ltc,
            "LUN" => Currency::Lun,
            "MAID" => Currency::Maid,
            "MANA" => Currency::Mana,
            "MATIC" => Currency::Matic,
            "MCO" => Currency::Mco,
            "MDA" => Currency::Mda,
            "MFT" => Currency::Mft,
            "MITH" => Currency::Mith,
            "MOD" => Currency::Mod,
            "MTH" => Currency::Mth,
            "MTL" => Currency::Mtl,
            "NANO" => Currency::Nano,
            "NAS" => Currency::Nas,
            "NAV" => Currency::Nav,
            "NCASH" => Currency::Ncash,
            "NEBL" => Currency::Nebl,
            "NEO" => Currency::Neo,
            "NGN" => Currency::Ngn,
            "NKN" => Currency::Nkn,
            "NMR" => Currency::Nmr,
            "NPXS" => Currency::Npxs,
            "NULS" => Currency::Nuls,
            "NXS" => Currency::Nxs,
            "NXT" => Currency::Nxt,
            "OAX" => Currency::Oax,
            "OMG" => Currency::Omg,
            "OMNI" => Currency::Omni,
            "ONE" => Currency::One,
            "ONG" => Currency::Ong,
            "ONT" => Currency::Ont,
            "OST" => Currency::Ost,
            "PAX" => Currency::Pax,
            "PERL" => Currency::Perl,
            "PHB" => Currency::Phb,
            "PHX" => Currency::Phx,
            "PIVX" => Currency::Pivx,
            "POA" => Currency::Poa,
            "POE" => Currency::Poe,
            "POLY" => Currency::Poly,
            "POWR" => Currency::Powr,
            "PPT" => Currency::Ppt,
            "QKC" => Currency::Qkc,
            "QLC" => Currency::Qlc,
            "QSP" => Currency::Qsp,
            "QTUM" => Currency::Qtum,
            "RCN" => Currency::Rcn,
            "RDN" => Currency::Rdn,
            "REN" => Currency::Ren,
            "REP" => Currency::Rep,
            "REQ" => Currency::Req,
            "RLC" => Currency::Rlc,
            "RPX" => Currency::Rpx,
            "RUB" => Currency::Rub,
            "RVN" => Currency::Rvn,
            "SALT" => Currency::Salt,
            "SC" => Currency::Sc,
            "SKY" => Currency::Sky,
            "SNGLS" => Currency::Sngls,
            "SNM" => Currency::Snm,
            "SNT" => Currency::Snt,
            "STEEM" => Currency::Steem,
            "STORJ" => Currency::Storj,
            "STORM" => Currency::Storm,
            "STR" => Currency::Str,
            "STRAT" => Currency::Strat,
            "STX" => Currency::Stx,
            "SUB" => Currency::Sub,
            "SYS" => Currency::Sys,
            "TFUEL" => Currency::Tfuel,
            "THETA" => Currency::Theta,
            "TNB" => Currency::Tnb,
            "TNT" => Currency::Tnt,
            "TOMO" => Currency::Tomo,
            "TRIG" => Currency::Trig,
            "TROY" => Currency::Troy,
            "TRX" => Currency::Trx,
            "TRY" => Currency::Try,
            "TUSD" => Currency::Tusd,
            "TUSDB" => Currency::Tusdb,
            "USDC" => Currency::Usdc,
            "USDS" => Currency::Usds,
            "USDSB" => Currency::Usdsb,
            "USDT" => Currency::Usdt,
            "VEN" => Currency::Ven,
            "VET" => Currency::Vet,
            "VIA" => Currency::Via,
            "VIB" => Currency::Vib,
            "VIBE" => Currency::Vibe,
            "VITE" => Currency::Vite,
            "VTC" => Currency::Vtc,
            "WABI" => Currency::Wabi,
            "WAN" => Currency::Wan,
            "WAVES" => Currency::Waves,
            "WIN" => Currency::Win,
            "WINGS" => Currency::Wings,
            "WPR" => Currency::Wpr,
            "WTC" => Currency::Wtc,
            "XEM" => Currency::Xem,
            "XLM" => Currency::Xlm,
            "XMR" => Currency::Xmr,
            "XPM" => Currency::Xpm,
            "XRP" => Currency::Xrp,
            "XTZ" => Currency::Xtz,
            "XVG" => Currency::Xvg,
            "XZC" => Currency::Xzc,
            "YOYO" => Currency::Yoyo,
            "ZEC" => Currency::Zec,
            "ZEN" => Currency::Zen,
            "ZIL" => Currency::Zil,
            "ZRX" => Currency::Zrx,
            sym => Currency::Custom(sym.to_owned()),
        }
    }
}

/// Currency pair.
#[derive(Eq, PartialEq, PartialOrd, Ord, Clone, Hash, Debug)]
pub enum CurrencyPair {
    Custom(String, Currency, Currency),
    AdaBnb,
    AdaBtc,
    AdaBusd,
    AdaEth,
    AdaPax,
    AdaTusd,
    AdaUsdc,
    AdaUsdt,
    AdxBnb,
    AdxBtc,
    AdxEth,
    AeBnb,
    AeBtc,
    AeEth,
    AgiBnb,
    AgiBtc,
    AgiEth,
    AionBnb,
    AionBtc,
    AionEth,
    AlgoBnb,
    AlgoBtc,
    AlgoPax,
    AlgoTusd,
    AlgoUsdc,
    AlgoUsdt,
    AmbBnb,
    AmbBtc,
    AmbEth,
    AnkrBnb,
    AnkrBtc,
    AnkrPax,
    AnkrTusd,
    AnkrUsdc,
    AnkrUsdt,
    AppcBnb,
    AppcBtc,
    AppcEth,
    ArdrBnb,
    ArdrBtc,
    ArdrEth,
    ArkBtc,
    ArkEth,
    ArnBtc,
    ArnEth,
    ArpaBnb,
    ArpaBtc,
    ArpaUsdt,
    AstBtc,
    AstEth,
    AtomBnb,
    AtomBtc,
    AtomPax,
    AtomTusd,
    AtomUsdc,
    AtomUsdt,
    BandBnb,
    BandBtc,
    BandUsdt,
    BatBnb,
    BatBtc,
    BatEth,
    BatPax,
    BatTusd,
    BatUsdc,
    BatUsdt,
    BccBnb,
    BccBtc,
    BccEth,
    BccUsdt,
    BcdBtc,
    BcdEth,
    BchabcBtc,
    BchabcBusd,
    BchabcPax,
    BchabcTusd,
    BchabcUsdc,
    BchabcUsdt,
    BchsvBtc,
    BchsvPax,
    BchsvTusd,
    BchsvUsdc,
    BchsvUsdt,
    BchBnb,
    BchBtc,
    BchBusd,
    BchPax,
    BchTusd,
    BchUsdc,
    BchUsdt,
    BcnBnb,
    BcnBtc,
    BcnEth,
    BcptBnb,
    BcptBtc,
    BcptEth,
    BcptPax,
    BcptTusd,
    BcptUsdc,
    BeamBnb,
    BeamBtc,
    BeamUsdt,
    BgbpUsdc,
    BlzBnb,
    BlzBtc,
    BlzEth,
    BnbBtc,
    BnbBusd,
    BnbEth,
    BnbNgn,
    BnbPax,
    BnbRub,
    BnbTry,
    BnbTusd,
    BnbUsdc,
    BnbUsds,
    BnbUsdt,
    BntBtc,
    BntEth,
    BqxBtc,
    BqxEth,
    BrdBnb,
    BrdBtc,
    BrdEth,
    BtcbBtc,
    BtcBusd,
    BtcDgb,
    BtcFct,
    BtcFoam,
    BtcGrin,
    BtcLpt,
    BtcMaid,
    BtcNgn,
    BtcNmr,
    BtcNxt,
    BtcOmni,
    BtcPax,
    BtcRub,
    BtcStr,
    BtcTry,
    BtcTusd,
    BtcUsdc,
    BtcUsds,
    BtcUsdt,
    BtcVtc,
    BtcXpm,
    BtgBtc,
    BtgEth,
    BtsBnb,
    BtsBtc,
    BtsEth,
    BttBnb,
    BttBtc,
    BttPax,
    BttTrx,
    BttTusd,
    BttUsdc,
    BttUsdt,
    BusdNgn,
    BusdRub,
    BusdTry,
    BusdUsdt,
    CdtBtc,
    CdtEth,
    CelrBnb,
    CelrBtc,
    CelrUsdt,
    ChatBtc,
    ChatEth,
    ChzBnb,
    ChzBtc,
    ChzUsdt,
    CloakBtc,
    CloakEth,
    CmtBnb,
    CmtBtc,
    CmtEth,
    CndBnb,
    CndBtc,
    CndEth,
    CocosBnb,
    CocosBtc,
    CocosUsdt,
    CosBnb,
    CosBtc,
    CosUsdt,
    CtxcBnb,
    CtxcBtc,
    CtxcUsdt,
    CvcBnb,
    CvcBtc,
    CvcEth,
    CvcUsdt,
    DashBnb,
    DashBtc,
    DashEth,
    DashUsdt,
    DataBtc,
    DataEth,
    DcrBnb,
    DcrBtc,
    DentBtc,
    DentEth,
    DentUsdt,
    DgdBtc,
    DgdEth,
    DltBnb,
    DltBtc,
    DltEth,
    DntBtc,
    DntEth,
    DockBtc,
    DockEth,
    DockUsdt,
    DogeBnb,
    DogeBtc,
    DogePax,
    DogeUsdc,
    DogeUsdt,
    DuskBnb,
    DuskBtc,
    DuskPax,
    DuskUsdc,
    DuskUsdt,
    EdoBtc,
    EdoEth,
    ElfBtc,
    ElfEth,
    EngBtc,
    EngEth,
    EnjBnb,
    EnjBtc,
    EnjEth,
    EnjUsdt,
    EosBnb,
    EosBtc,
    EosBusd,
    EosEth,
    EosPax,
    EosTusd,
    EosUsdc,
    EosUsdt,
    ErdBnb,
    ErdBtc,
    ErdPax,
    ErdUsdc,
    ErdUsdt,
    EtcBnb,
    EtcBtc,
    EtcBusd,
    EtcEth,
    EtcPax,
    EtcTusd,
    EtcUsdc,
    EtcUsdt,
    EthBtc,
    EthBusd,
    EthPax,
    EthRub,
    EthTry,
    EthTusd,
    EthUsdc,
    EthUsdt,
    EvxBtc,
    EvxEth,
    FetBnb,
    FetBtc,
    FetUsdt,
    FtmBnb,
    FtmBtc,
    FtmPax,
    FtmTusd,
    FtmUsdc,
    FtmUsdt,
    FttBnb,
    FttBtc,
    FttUsdt,
    FuelBtc,
    FuelEth,
    FunBtc,
    FunEth,
    FunUsdt,
    GasBtc,
    GntBnb,
    GntBtc,
    GntEth,
    GoBnb,
    GoBtc,
    GrsBtc,
    GrsEth,
    GtoBnb,
    GtoBtc,
    GtoEth,
    GtoPax,
    GtoTusd,
    GtoUsdc,
    GtoUsdt,
    GvtBtc,
    GvtEth,
    GxsBtc,
    GxsEth,
    HbarBnb,
    HbarBtc,
    HbarUsdt,
    HcBtc,
    HcEth,
    HcUsdt,
    HotBnb,
    HotBtc,
    HotEth,
    HotUsdt,
    HsrBtc,
    HsrEth,
    IcnBtc,
    IcnEth,
    IcxBnb,
    IcxBtc,
    IcxEth,
    IcxUsdt,
    InsBtc,
    InsEth,
    IostBnb,
    IostBtc,
    IostEth,
    IostUsdt,
    IotaBnb,
    IotaBtc,
    IotaEth,
    IotaUsdt,
    IotxBtc,
    IotxEth,
    IotxUsdt,
    KavaBnb,
    KavaBtc,
    KavaUsdt,
    KeyBtc,
    KeyEth,
    KeyUsdt,
    KmdBtc,
    KmdEth,
    KncBtc,
    KncEth,
    LendBtc,
    LendEth,
    LinkBtc,
    LinkBusd,
    LinkEth,
    LinkPax,
    LinkTusd,
    LinkUsdc,
    LinkUsdt,
    LoomBnb,
    LoomBtc,
    LoomEth,
    LrcBtc,
    LrcEth,
    LskBnb,
    LskBtc,
    LskEth,
    LtcBnb,
    LtcBtc,
    LtcBusd,
    LtcEth,
    LtcPax,
    LtcTusd,
    LtcUsdc,
    LtcUsdt,
    LunBtc,
    LunEth,
    ManaBtc,
    ManaEth,
    MaticBnb,
    MaticBtc,
    MaticUsdt,
    McoBnb,
    McoBtc,
    McoEth,
    McoUsdt,
    MdaBtc,
    MdaEth,
    MftBnb,
    MftBtc,
    MftEth,
    MftUsdt,
    MithBnb,
    MithBtc,
    MithUsdt,
    ModBtc,
    ModEth,
    MthBtc,
    MthEth,
    MtlBtc,
    MtlEth,
    MtlUsdt,
    NanoBnb,
    NanoBtc,
    NanoEth,
    NanoUsdt,
    NasBnb,
    NasBtc,
    NasEth,
    NavBnb,
    NavBtc,
    NavEth,
    NcashBnb,
    NcashBtc,
    NcashEth,
    NeblBnb,
    NeblBtc,
    NeblEth,
    NeoBnb,
    NeoBtc,
    NeoEth,
    NeoPax,
    NeoTusd,
    NeoUsdc,
    NeoUsdt,
    NknBnb,
    NknBtc,
    NknUsdt,
    NpxsBtc,
    NpxsEth,
    NpxsUsdc,
    NpxsUsdt,
    NulsBnb,
    NulsBtc,
    NulsEth,
    NulsUsdt,
    NxsBnb,
    NxsBtc,
    NxsEth,
    OaxBtc,
    OaxEth,
    OmgBnb,
    OmgBtc,
    OmgEth,
    OmgUsdt,
    OneBnb,
    OneBtc,
    OnePax,
    OneTusd,
    OneUsdc,
    OneUsdt,
    OngBnb,
    OngBtc,
    OngUsdt,
    OntBnb,
    OntBtc,
    OntEth,
    OntPax,
    OntUsdc,
    OntUsdt,
    OstBnb,
    OstBtc,
    OstEth,
    PaxBnb,
    PaxBtc,
    PaxEth,
    PaxTusd,
    PaxUsdt,
    PerlBnb,
    PerlBtc,
    PerlUsdc,
    PerlUsdt,
    PhbBnb,
    PhbBtc,
    PhbPax,
    PhbTusd,
    PhbUsdc,
    PhxBnb,
    PhxBtc,
    PhxEth,
    PivxBnb,
    PivxBtc,
    PivxEth,
    PoaBnb,
    PoaBtc,
    PoaEth,
    PoeBtc,
    PoeEth,
    PolyBnb,
    PolyBtc,
    PowrBnb,
    PowrBtc,
    PowrEth,
    PptBtc,
    PptEth,
    QkcBtc,
    QkcEth,
    QlcBnb,
    QlcBtc,
    QlcEth,
    QspBnb,
    QspBtc,
    QspEth,
    QtumBnb,
    QtumBtc,
    QtumBusd,
    QtumEth,
    QtumUsdt,
    RcnBnb,
    RcnBtc,
    RcnEth,
    RdnBnb,
    RdnBtc,
    RdnEth,
    RenBnb,
    RenBtc,
    RenUsdt,
    RepBnb,
    RepBtc,
    RepEth,
    ReqBtc,
    ReqEth,
    RlcBnb,
    RlcBtc,
    RlcEth,
    RlcUsdt,
    RpxBnb,
    RpxBtc,
    RpxEth,
    RvnBnb,
    RvnBtc,
    RvnUsdt,
    SaltBtc,
    SaltEth,
    ScBnb,
    ScBtc,
    ScEth,
    SkyBnb,
    SkyBtc,
    SkyEth,
    SnglsBtc,
    SnglsEth,
    SnmBtc,
    SnmEth,
    SntBtc,
    SntEth,
    SteemBnb,
    SteemBtc,
    SteemEth,
    StorjBtc,
    StorjEth,
    StormBnb,
    StormBtc,
    StormEth,
    StormUsdt,
    StratBtc,
    StratEth,
    StxBnb,
    StxBtc,
    StxUsdt,
    SubBtc,
    SubEth,
    SysBnb,
    SysBtc,
    SysEth,
    TfuelBnb,
    TfuelBtc,
    TfuelPax,
    TfuelTusd,
    TfuelUsdc,
    TfuelUsdt,
    ThetaBnb,
    ThetaBtc,
    ThetaEth,
    ThetaUsdt,
    TnbBtc,
    TnbEth,
    TntBtc,
    TntEth,
    TomoBnb,
    TomoBtc,
    TomoUsdc,
    TomoUsdt,
    TrigBnb,
    TrigBtc,
    TrigEth,
    TroyBnb,
    TroyBtc,
    TroyUsdt,
    TrxBnb,
    TrxBtc,
    TrxBusd,
    TrxEth,
    TrxPax,
    TrxTusd,
    TrxUsdc,
    TrxUsdt,
    TrxXrp,
    TusdbTusd,
    TusdBnb,
    TusdBtc,
    TusdEth,
    TusdUsdt,
    UsdcBnb,
    UsdcDash,
    UsdcGrin,
    UsdcPax,
    UsdcStr,
    UsdcTusd,
    UsdcUsdt,
    UsdcXmr,
    UsdsbUsds,
    UsdsbUsdt,
    UsdsPax,
    UsdsTusd,
    UsdsUsdc,
    UsdsUsdt,
    UsdtDgb,
    UsdtGnt,
    UsdtGrin,
    UsdtLsk,
    UsdtMana,
    UsdtNxt,
    UsdtRep,
    UsdtRub,
    UsdtSc,
    UsdtStr,
    UsdtTry,
    VenBnb,
    VenBtc,
    VenEth,
    VenUsdt,
    VetBnb,
    VetBtc,
    VetBusd,
    VetEth,
    VetUsdt,
    ViaBnb,
    ViaBtc,
    ViaEth,
    VibeBtc,
    VibeEth,
    VibBtc,
    VibEth,
    ViteBnb,
    ViteBtc,
    ViteUsdt,
    WabiBnb,
    WabiBtc,
    WabiEth,
    WanBnb,
    WanBtc,
    WanEth,
    WanUsdt,
    WavesBnb,
    WavesBtc,
    WavesEth,
    WavesPax,
    WavesTusd,
    WavesUsdc,
    WavesUsdt,
    WingsBtc,
    WingsEth,
    WinBnb,
    WinBtc,
    WinTrx,
    WinUsdc,
    WinUsdt,
    WprBtc,
    WprEth,
    WtcBnb,
    WtcBtc,
    WtcEth,
    XemBnb,
    XemBtc,
    XemEth,
    XlmBnb,
    XlmBtc,
    XlmBusd,
    XlmEth,
    XlmPax,
    XlmTusd,
    XlmUsdc,
    XlmUsdt,
    XmrBnb,
    XmrBtc,
    XmrEth,
    XmrUsdt,
    XrpBnb,
    XrpBtc,
    XrpBusd,
    XrpEth,
    XrpPax,
    XrpRub,
    XrpTry,
    XrpTusd,
    XrpUsdc,
    XrpUsdt,
    XtzBnb,
    XtzBtc,
    XtzUsdt,
    XvgBtc,
    XvgEth,
    XzcBnb,
    XzcBtc,
    XzcEth,
    XzcXrp,
    YoyoBnb,
    YoyoBtc,
    YoyoEth,
    ZecBnb,
    ZecBtc,
    ZecEth,
    ZecPax,
    ZecTusd,
    ZecUsdc,
    ZecUsdt,
    ZenBnb,
    ZenBtc,
    ZenEth,
    ZilBnb,
    ZilBtc,
    ZilEth,
    ZilUsdt,
    ZrxBnb,
    ZrxBtc,
    ZrxEth,
    ZrxUsdt,
}

impl CurrencyPair {
    pub fn new(quote: Currency, base: Currency) -> CurrencyPair {
        match (quote, base) {
            (Currency::Ada, Currency::Bnb) => CurrencyPair::AdaBnb,
            (Currency::Ada, Currency::Btc) => CurrencyPair::AdaBtc,
            (Currency::Ada, Currency::Busd) => CurrencyPair::AdaBusd,
            (Currency::Ada, Currency::Eth) => CurrencyPair::AdaEth,
            (Currency::Ada, Currency::Pax) => CurrencyPair::AdaPax,
            (Currency::Ada, Currency::Tusd) => CurrencyPair::AdaTusd,
            (Currency::Ada, Currency::Usdc) => CurrencyPair::AdaUsdc,
            (Currency::Ada, Currency::Usdt) => CurrencyPair::AdaUsdt,
            (Currency::Adx, Currency::Bnb) => CurrencyPair::AdxBnb,
            (Currency::Adx, Currency::Btc) => CurrencyPair::AdxBtc,
            (Currency::Adx, Currency::Eth) => CurrencyPair::AdxEth,
            (Currency::Ae, Currency::Bnb) => CurrencyPair::AeBnb,
            (Currency::Ae, Currency::Btc) => CurrencyPair::AeBtc,
            (Currency::Ae, Currency::Eth) => CurrencyPair::AeEth,
            (Currency::Agi, Currency::Bnb) => CurrencyPair::AgiBnb,
            (Currency::Agi, Currency::Btc) => CurrencyPair::AgiBtc,
            (Currency::Agi, Currency::Eth) => CurrencyPair::AgiEth,
            (Currency::Aion, Currency::Bnb) => CurrencyPair::AionBnb,
            (Currency::Aion, Currency::Btc) => CurrencyPair::AionBtc,
            (Currency::Aion, Currency::Eth) => CurrencyPair::AionEth,
            (Currency::Algo, Currency::Bnb) => CurrencyPair::AlgoBnb,
            (Currency::Algo, Currency::Btc) => CurrencyPair::AlgoBtc,
            (Currency::Algo, Currency::Pax) => CurrencyPair::AlgoPax,
            (Currency::Algo, Currency::Tusd) => CurrencyPair::AlgoTusd,
            (Currency::Algo, Currency::Usdc) => CurrencyPair::AlgoUsdc,
            (Currency::Algo, Currency::Usdt) => CurrencyPair::AlgoUsdt,
            (Currency::Amb, Currency::Bnb) => CurrencyPair::AmbBnb,
            (Currency::Amb, Currency::Btc) => CurrencyPair::AmbBtc,
            (Currency::Amb, Currency::Eth) => CurrencyPair::AmbEth,
            (Currency::Ankr, Currency::Bnb) => CurrencyPair::AnkrBnb,
            (Currency::Ankr, Currency::Btc) => CurrencyPair::AnkrBtc,
            (Currency::Ankr, Currency::Pax) => CurrencyPair::AnkrPax,
            (Currency::Ankr, Currency::Tusd) => CurrencyPair::AnkrTusd,
            (Currency::Ankr, Currency::Usdc) => CurrencyPair::AnkrUsdc,
            (Currency::Ankr, Currency::Usdt) => CurrencyPair::AnkrUsdt,
            (Currency::Appc, Currency::Bnb) => CurrencyPair::AppcBnb,
            (Currency::Appc, Currency::Btc) => CurrencyPair::AppcBtc,
            (Currency::Appc, Currency::Eth) => CurrencyPair::AppcEth,
            (Currency::Ardr, Currency::Bnb) => CurrencyPair::ArdrBnb,
            (Currency::Ardr, Currency::Btc) => CurrencyPair::ArdrBtc,
            (Currency::Ardr, Currency::Eth) => CurrencyPair::ArdrEth,
            (Currency::Ark, Currency::Btc) => CurrencyPair::ArkBtc,
            (Currency::Ark, Currency::Eth) => CurrencyPair::ArkEth,
            (Currency::Arn, Currency::Btc) => CurrencyPair::ArnBtc,
            (Currency::Arn, Currency::Eth) => CurrencyPair::ArnEth,
            (Currency::Arpa, Currency::Bnb) => CurrencyPair::ArpaBnb,
            (Currency::Arpa, Currency::Btc) => CurrencyPair::ArpaBtc,
            (Currency::Arpa, Currency::Usdt) => CurrencyPair::ArpaUsdt,
            (Currency::Ast, Currency::Btc) => CurrencyPair::AstBtc,
            (Currency::Ast, Currency::Eth) => CurrencyPair::AstEth,
            (Currency::Atom, Currency::Bnb) => CurrencyPair::AtomBnb,
            (Currency::Atom, Currency::Btc) => CurrencyPair::AtomBtc,
            (Currency::Atom, Currency::Pax) => CurrencyPair::AtomPax,
            (Currency::Atom, Currency::Tusd) => CurrencyPair::AtomTusd,
            (Currency::Atom, Currency::Usdc) => CurrencyPair::AtomUsdc,
            (Currency::Atom, Currency::Usdt) => CurrencyPair::AtomUsdt,
            (Currency::Band, Currency::Bnb) => CurrencyPair::BandBnb,
            (Currency::Band, Currency::Btc) => CurrencyPair::BandBtc,
            (Currency::Band, Currency::Usdt) => CurrencyPair::BandUsdt,
            (Currency::Bat, Currency::Bnb) => CurrencyPair::BatBnb,
            (Currency::Bat, Currency::Btc) => CurrencyPair::BatBtc,
            (Currency::Bat, Currency::Eth) => CurrencyPair::BatEth,
            (Currency::Bat, Currency::Pax) => CurrencyPair::BatPax,
            (Currency::Bat, Currency::Tusd) => CurrencyPair::BatTusd,
            (Currency::Bat, Currency::Usdc) => CurrencyPair::BatUsdc,
            (Currency::Bat, Currency::Usdt) => CurrencyPair::BatUsdt,
            (Currency::Bcc, Currency::Bnb) => CurrencyPair::BccBnb,
            (Currency::Bcc, Currency::Btc) => CurrencyPair::BccBtc,
            (Currency::Bcc, Currency::Eth) => CurrencyPair::BccEth,
            (Currency::Bcc, Currency::Usdt) => CurrencyPair::BccUsdt,
            (Currency::Bcd, Currency::Btc) => CurrencyPair::BcdBtc,
            (Currency::Bcd, Currency::Eth) => CurrencyPair::BcdEth,
            (Currency::Bchabc, Currency::Btc) => CurrencyPair::BchabcBtc,
            (Currency::Bchabc, Currency::Busd) => CurrencyPair::BchabcBusd,
            (Currency::Bchabc, Currency::Pax) => CurrencyPair::BchabcPax,
            (Currency::Bchabc, Currency::Tusd) => CurrencyPair::BchabcTusd,
            (Currency::Bchabc, Currency::Usdc) => CurrencyPair::BchabcUsdc,
            (Currency::Bchabc, Currency::Usdt) => CurrencyPair::BchabcUsdt,
            (Currency::Bchsv, Currency::Btc) => CurrencyPair::BchsvBtc,
            (Currency::Bchsv, Currency::Pax) => CurrencyPair::BchsvPax,
            (Currency::Bchsv, Currency::Tusd) => CurrencyPair::BchsvTusd,
            (Currency::Bchsv, Currency::Usdc) => CurrencyPair::BchsvUsdc,
            (Currency::Bchsv, Currency::Usdt) => CurrencyPair::BchsvUsdt,
            (Currency::Bch, Currency::Bnb) => CurrencyPair::BchBnb,
            (Currency::Bch, Currency::Btc) => CurrencyPair::BchBtc,
            (Currency::Bch, Currency::Busd) => CurrencyPair::BchBusd,
            (Currency::Bch, Currency::Pax) => CurrencyPair::BchPax,
            (Currency::Bch, Currency::Tusd) => CurrencyPair::BchTusd,
            (Currency::Bch, Currency::Usdc) => CurrencyPair::BchUsdc,
            (Currency::Bch, Currency::Usdt) => CurrencyPair::BchUsdt,
            (Currency::Bcn, Currency::Bnb) => CurrencyPair::BcnBnb,
            (Currency::Bcn, Currency::Btc) => CurrencyPair::BcnBtc,
            (Currency::Bcn, Currency::Eth) => CurrencyPair::BcnEth,
            (Currency::Bcpt, Currency::Bnb) => CurrencyPair::BcptBnb,
            (Currency::Bcpt, Currency::Btc) => CurrencyPair::BcptBtc,
            (Currency::Bcpt, Currency::Eth) => CurrencyPair::BcptEth,
            (Currency::Bcpt, Currency::Pax) => CurrencyPair::BcptPax,
            (Currency::Bcpt, Currency::Tusd) => CurrencyPair::BcptTusd,
            (Currency::Bcpt, Currency::Usdc) => CurrencyPair::BcptUsdc,
            (Currency::Beam, Currency::Bnb) => CurrencyPair::BeamBnb,
            (Currency::Beam, Currency::Btc) => CurrencyPair::BeamBtc,
            (Currency::Beam, Currency::Usdt) => CurrencyPair::BeamUsdt,
            (Currency::Bgbp, Currency::Usdc) => CurrencyPair::BgbpUsdc,
            (Currency::Blz, Currency::Bnb) => CurrencyPair::BlzBnb,
            (Currency::Blz, Currency::Btc) => CurrencyPair::BlzBtc,
            (Currency::Blz, Currency::Eth) => CurrencyPair::BlzEth,
            (Currency::Bnb, Currency::Btc) => CurrencyPair::BnbBtc,
            (Currency::Bnb, Currency::Busd) => CurrencyPair::BnbBusd,
            (Currency::Bnb, Currency::Eth) => CurrencyPair::BnbEth,
            (Currency::Bnb, Currency::Ngn) => CurrencyPair::BnbNgn,
            (Currency::Bnb, Currency::Pax) => CurrencyPair::BnbPax,
            (Currency::Bnb, Currency::Rub) => CurrencyPair::BnbRub,
            (Currency::Bnb, Currency::Try) => CurrencyPair::BnbTry,
            (Currency::Bnb, Currency::Tusd) => CurrencyPair::BnbTusd,
            (Currency::Bnb, Currency::Usdc) => CurrencyPair::BnbUsdc,
            (Currency::Bnb, Currency::Usds) => CurrencyPair::BnbUsds,
            (Currency::Bnb, Currency::Usdt) => CurrencyPair::BnbUsdt,
            (Currency::Bnt, Currency::Btc) => CurrencyPair::BntBtc,
            (Currency::Bnt, Currency::Eth) => CurrencyPair::BntEth,
            (Currency::Bqx, Currency::Btc) => CurrencyPair::BqxBtc,
            (Currency::Bqx, Currency::Eth) => CurrencyPair::BqxEth,
            (Currency::Brd, Currency::Bnb) => CurrencyPair::BrdBnb,
            (Currency::Brd, Currency::Btc) => CurrencyPair::BrdBtc,
            (Currency::Brd, Currency::Eth) => CurrencyPair::BrdEth,
            (Currency::Btcb, Currency::Btc) => CurrencyPair::BtcbBtc,
            (Currency::Btc, Currency::Busd) => CurrencyPair::BtcBusd,
            (Currency::Btc, Currency::Dgb) => CurrencyPair::BtcDgb,
            (Currency::Btc, Currency::Fct) => CurrencyPair::BtcFct,
            (Currency::Btc, Currency::Foam) => CurrencyPair::BtcFoam,
            (Currency::Btc, Currency::Grin) => CurrencyPair::BtcGrin,
            (Currency::Btc, Currency::Lpt) => CurrencyPair::BtcLpt,
            (Currency::Btc, Currency::Maid) => CurrencyPair::BtcMaid,
            (Currency::Btc, Currency::Ngn) => CurrencyPair::BtcNgn,
            (Currency::Btc, Currency::Nmr) => CurrencyPair::BtcNmr,
            (Currency::Btc, Currency::Nxt) => CurrencyPair::BtcNxt,
            (Currency::Btc, Currency::Omni) => CurrencyPair::BtcOmni,
            (Currency::Btc, Currency::Pax) => CurrencyPair::BtcPax,
            (Currency::Btc, Currency::Rub) => CurrencyPair::BtcRub,
            (Currency::Btc, Currency::Str) => CurrencyPair::BtcStr,
            (Currency::Btc, Currency::Try) => CurrencyPair::BtcTry,
            (Currency::Btc, Currency::Tusd) => CurrencyPair::BtcTusd,
            (Currency::Btc, Currency::Usdc) => CurrencyPair::BtcUsdc,
            (Currency::Btc, Currency::Usds) => CurrencyPair::BtcUsds,
            (Currency::Btc, Currency::Usdt) => CurrencyPair::BtcUsdt,
            (Currency::Btc, Currency::Vtc) => CurrencyPair::BtcVtc,
            (Currency::Btc, Currency::Xpm) => CurrencyPair::BtcXpm,
            (Currency::Btg, Currency::Btc) => CurrencyPair::BtgBtc,
            (Currency::Btg, Currency::Eth) => CurrencyPair::BtgEth,
            (Currency::Bts, Currency::Bnb) => CurrencyPair::BtsBnb,
            (Currency::Bts, Currency::Btc) => CurrencyPair::BtsBtc,
            (Currency::Bts, Currency::Eth) => CurrencyPair::BtsEth,
            (Currency::Btt, Currency::Bnb) => CurrencyPair::BttBnb,
            (Currency::Btt, Currency::Btc) => CurrencyPair::BttBtc,
            (Currency::Btt, Currency::Pax) => CurrencyPair::BttPax,
            (Currency::Btt, Currency::Trx) => CurrencyPair::BttTrx,
            (Currency::Btt, Currency::Tusd) => CurrencyPair::BttTusd,
            (Currency::Btt, Currency::Usdc) => CurrencyPair::BttUsdc,
            (Currency::Btt, Currency::Usdt) => CurrencyPair::BttUsdt,
            (Currency::Busd, Currency::Ngn) => CurrencyPair::BusdNgn,
            (Currency::Busd, Currency::Rub) => CurrencyPair::BusdRub,
            (Currency::Busd, Currency::Try) => CurrencyPair::BusdTry,
            (Currency::Busd, Currency::Usdt) => CurrencyPair::BusdUsdt,
            (Currency::Cdt, Currency::Btc) => CurrencyPair::CdtBtc,
            (Currency::Cdt, Currency::Eth) => CurrencyPair::CdtEth,
            (Currency::Celr, Currency::Bnb) => CurrencyPair::CelrBnb,
            (Currency::Celr, Currency::Btc) => CurrencyPair::CelrBtc,
            (Currency::Celr, Currency::Usdt) => CurrencyPair::CelrUsdt,
            (Currency::Chat, Currency::Btc) => CurrencyPair::ChatBtc,
            (Currency::Chat, Currency::Eth) => CurrencyPair::ChatEth,
            (Currency::Chz, Currency::Bnb) => CurrencyPair::ChzBnb,
            (Currency::Chz, Currency::Btc) => CurrencyPair::ChzBtc,
            (Currency::Chz, Currency::Usdt) => CurrencyPair::ChzUsdt,
            (Currency::Cloak, Currency::Btc) => CurrencyPair::CloakBtc,
            (Currency::Cloak, Currency::Eth) => CurrencyPair::CloakEth,
            (Currency::Cmt, Currency::Bnb) => CurrencyPair::CmtBnb,
            (Currency::Cmt, Currency::Btc) => CurrencyPair::CmtBtc,
            (Currency::Cmt, Currency::Eth) => CurrencyPair::CmtEth,
            (Currency::Cnd, Currency::Bnb) => CurrencyPair::CndBnb,
            (Currency::Cnd, Currency::Btc) => CurrencyPair::CndBtc,
            (Currency::Cnd, Currency::Eth) => CurrencyPair::CndEth,
            (Currency::Cocos, Currency::Bnb) => CurrencyPair::CocosBnb,
            (Currency::Cocos, Currency::Btc) => CurrencyPair::CocosBtc,
            (Currency::Cocos, Currency::Usdt) => CurrencyPair::CocosUsdt,
            (Currency::Cos, Currency::Bnb) => CurrencyPair::CosBnb,
            (Currency::Cos, Currency::Btc) => CurrencyPair::CosBtc,
            (Currency::Cos, Currency::Usdt) => CurrencyPair::CosUsdt,
            (Currency::Ctxc, Currency::Bnb) => CurrencyPair::CtxcBnb,
            (Currency::Ctxc, Currency::Btc) => CurrencyPair::CtxcBtc,
            (Currency::Ctxc, Currency::Usdt) => CurrencyPair::CtxcUsdt,
            (Currency::Cvc, Currency::Bnb) => CurrencyPair::CvcBnb,
            (Currency::Cvc, Currency::Btc) => CurrencyPair::CvcBtc,
            (Currency::Cvc, Currency::Eth) => CurrencyPair::CvcEth,
            (Currency::Cvc, Currency::Usdt) => CurrencyPair::CvcUsdt,
            (Currency::Dash, Currency::Bnb) => CurrencyPair::DashBnb,
            (Currency::Dash, Currency::Btc) => CurrencyPair::DashBtc,
            (Currency::Dash, Currency::Eth) => CurrencyPair::DashEth,
            (Currency::Dash, Currency::Usdt) => CurrencyPair::DashUsdt,
            (Currency::Data, Currency::Btc) => CurrencyPair::DataBtc,
            (Currency::Data, Currency::Eth) => CurrencyPair::DataEth,
            (Currency::Dcr, Currency::Bnb) => CurrencyPair::DcrBnb,
            (Currency::Dcr, Currency::Btc) => CurrencyPair::DcrBtc,
            (Currency::Dent, Currency::Btc) => CurrencyPair::DentBtc,
            (Currency::Dent, Currency::Eth) => CurrencyPair::DentEth,
            (Currency::Dent, Currency::Usdt) => CurrencyPair::DentUsdt,
            (Currency::Dgd, Currency::Btc) => CurrencyPair::DgdBtc,
            (Currency::Dgd, Currency::Eth) => CurrencyPair::DgdEth,
            (Currency::Dlt, Currency::Bnb) => CurrencyPair::DltBnb,
            (Currency::Dlt, Currency::Btc) => CurrencyPair::DltBtc,
            (Currency::Dlt, Currency::Eth) => CurrencyPair::DltEth,
            (Currency::Dnt, Currency::Btc) => CurrencyPair::DntBtc,
            (Currency::Dnt, Currency::Eth) => CurrencyPair::DntEth,
            (Currency::Dock, Currency::Btc) => CurrencyPair::DockBtc,
            (Currency::Dock, Currency::Eth) => CurrencyPair::DockEth,
            (Currency::Dock, Currency::Usdt) => CurrencyPair::DockUsdt,
            (Currency::Doge, Currency::Bnb) => CurrencyPair::DogeBnb,
            (Currency::Doge, Currency::Btc) => CurrencyPair::DogeBtc,
            (Currency::Doge, Currency::Pax) => CurrencyPair::DogePax,
            (Currency::Doge, Currency::Usdc) => CurrencyPair::DogeUsdc,
            (Currency::Doge, Currency::Usdt) => CurrencyPair::DogeUsdt,
            (Currency::Dusk, Currency::Bnb) => CurrencyPair::DuskBnb,
            (Currency::Dusk, Currency::Btc) => CurrencyPair::DuskBtc,
            (Currency::Dusk, Currency::Pax) => CurrencyPair::DuskPax,
            (Currency::Dusk, Currency::Usdc) => CurrencyPair::DuskUsdc,
            (Currency::Dusk, Currency::Usdt) => CurrencyPair::DuskUsdt,
            (Currency::Edo, Currency::Btc) => CurrencyPair::EdoBtc,
            (Currency::Edo, Currency::Eth) => CurrencyPair::EdoEth,
            (Currency::Elf, Currency::Btc) => CurrencyPair::ElfBtc,
            (Currency::Elf, Currency::Eth) => CurrencyPair::ElfEth,
            (Currency::Eng, Currency::Btc) => CurrencyPair::EngBtc,
            (Currency::Eng, Currency::Eth) => CurrencyPair::EngEth,
            (Currency::Enj, Currency::Bnb) => CurrencyPair::EnjBnb,
            (Currency::Enj, Currency::Btc) => CurrencyPair::EnjBtc,
            (Currency::Enj, Currency::Eth) => CurrencyPair::EnjEth,
            (Currency::Enj, Currency::Usdt) => CurrencyPair::EnjUsdt,
            (Currency::Eos, Currency::Bnb) => CurrencyPair::EosBnb,
            (Currency::Eos, Currency::Btc) => CurrencyPair::EosBtc,
            (Currency::Eos, Currency::Busd) => CurrencyPair::EosBusd,
            (Currency::Eos, Currency::Eth) => CurrencyPair::EosEth,
            (Currency::Eos, Currency::Pax) => CurrencyPair::EosPax,
            (Currency::Eos, Currency::Tusd) => CurrencyPair::EosTusd,
            (Currency::Eos, Currency::Usdc) => CurrencyPair::EosUsdc,
            (Currency::Eos, Currency::Usdt) => CurrencyPair::EosUsdt,
            (Currency::Erd, Currency::Bnb) => CurrencyPair::ErdBnb,
            (Currency::Erd, Currency::Btc) => CurrencyPair::ErdBtc,
            (Currency::Erd, Currency::Pax) => CurrencyPair::ErdPax,
            (Currency::Erd, Currency::Usdc) => CurrencyPair::ErdUsdc,
            (Currency::Erd, Currency::Usdt) => CurrencyPair::ErdUsdt,
            (Currency::Etc, Currency::Bnb) => CurrencyPair::EtcBnb,
            (Currency::Etc, Currency::Btc) => CurrencyPair::EtcBtc,
            (Currency::Etc, Currency::Busd) => CurrencyPair::EtcBusd,
            (Currency::Etc, Currency::Eth) => CurrencyPair::EtcEth,
            (Currency::Etc, Currency::Pax) => CurrencyPair::EtcPax,
            (Currency::Etc, Currency::Tusd) => CurrencyPair::EtcTusd,
            (Currency::Etc, Currency::Usdc) => CurrencyPair::EtcUsdc,
            (Currency::Etc, Currency::Usdt) => CurrencyPair::EtcUsdt,
            (Currency::Eth, Currency::Btc) => CurrencyPair::EthBtc,
            (Currency::Eth, Currency::Busd) => CurrencyPair::EthBusd,
            (Currency::Eth, Currency::Pax) => CurrencyPair::EthPax,
            (Currency::Eth, Currency::Rub) => CurrencyPair::EthRub,
            (Currency::Eth, Currency::Try) => CurrencyPair::EthTry,
            (Currency::Eth, Currency::Tusd) => CurrencyPair::EthTusd,
            (Currency::Eth, Currency::Usdc) => CurrencyPair::EthUsdc,
            (Currency::Eth, Currency::Usdt) => CurrencyPair::EthUsdt,
            (Currency::Evx, Currency::Btc) => CurrencyPair::EvxBtc,
            (Currency::Evx, Currency::Eth) => CurrencyPair::EvxEth,
            (Currency::Fet, Currency::Bnb) => CurrencyPair::FetBnb,
            (Currency::Fet, Currency::Btc) => CurrencyPair::FetBtc,
            (Currency::Fet, Currency::Usdt) => CurrencyPair::FetUsdt,
            (Currency::Ftm, Currency::Bnb) => CurrencyPair::FtmBnb,
            (Currency::Ftm, Currency::Btc) => CurrencyPair::FtmBtc,
            (Currency::Ftm, Currency::Pax) => CurrencyPair::FtmPax,
            (Currency::Ftm, Currency::Tusd) => CurrencyPair::FtmTusd,
            (Currency::Ftm, Currency::Usdc) => CurrencyPair::FtmUsdc,
            (Currency::Ftm, Currency::Usdt) => CurrencyPair::FtmUsdt,
            (Currency::Ftt, Currency::Bnb) => CurrencyPair::FttBnb,
            (Currency::Ftt, Currency::Btc) => CurrencyPair::FttBtc,
            (Currency::Ftt, Currency::Usdt) => CurrencyPair::FttUsdt,
            (Currency::Fuel, Currency::Btc) => CurrencyPair::FuelBtc,
            (Currency::Fuel, Currency::Eth) => CurrencyPair::FuelEth,
            (Currency::Fun, Currency::Btc) => CurrencyPair::FunBtc,
            (Currency::Fun, Currency::Eth) => CurrencyPair::FunEth,
            (Currency::Fun, Currency::Usdt) => CurrencyPair::FunUsdt,
            (Currency::Gas, Currency::Btc) => CurrencyPair::GasBtc,
            (Currency::Gnt, Currency::Bnb) => CurrencyPair::GntBnb,
            (Currency::Gnt, Currency::Btc) => CurrencyPair::GntBtc,
            (Currency::Gnt, Currency::Eth) => CurrencyPair::GntEth,
            (Currency::Go, Currency::Bnb) => CurrencyPair::GoBnb,
            (Currency::Go, Currency::Btc) => CurrencyPair::GoBtc,
            (Currency::Grs, Currency::Btc) => CurrencyPair::GrsBtc,
            (Currency::Grs, Currency::Eth) => CurrencyPair::GrsEth,
            (Currency::Gto, Currency::Bnb) => CurrencyPair::GtoBnb,
            (Currency::Gto, Currency::Btc) => CurrencyPair::GtoBtc,
            (Currency::Gto, Currency::Eth) => CurrencyPair::GtoEth,
            (Currency::Gto, Currency::Pax) => CurrencyPair::GtoPax,
            (Currency::Gto, Currency::Tusd) => CurrencyPair::GtoTusd,
            (Currency::Gto, Currency::Usdc) => CurrencyPair::GtoUsdc,
            (Currency::Gto, Currency::Usdt) => CurrencyPair::GtoUsdt,
            (Currency::Gvt, Currency::Btc) => CurrencyPair::GvtBtc,
            (Currency::Gvt, Currency::Eth) => CurrencyPair::GvtEth,
            (Currency::Gxs, Currency::Btc) => CurrencyPair::GxsBtc,
            (Currency::Gxs, Currency::Eth) => CurrencyPair::GxsEth,
            (Currency::Hbar, Currency::Bnb) => CurrencyPair::HbarBnb,
            (Currency::Hbar, Currency::Btc) => CurrencyPair::HbarBtc,
            (Currency::Hbar, Currency::Usdt) => CurrencyPair::HbarUsdt,
            (Currency::Hc, Currency::Btc) => CurrencyPair::HcBtc,
            (Currency::Hc, Currency::Eth) => CurrencyPair::HcEth,
            (Currency::Hc, Currency::Usdt) => CurrencyPair::HcUsdt,
            (Currency::Hot, Currency::Bnb) => CurrencyPair::HotBnb,
            (Currency::Hot, Currency::Btc) => CurrencyPair::HotBtc,
            (Currency::Hot, Currency::Eth) => CurrencyPair::HotEth,
            (Currency::Hot, Currency::Usdt) => CurrencyPair::HotUsdt,
            (Currency::Hsr, Currency::Btc) => CurrencyPair::HsrBtc,
            (Currency::Hsr, Currency::Eth) => CurrencyPair::HsrEth,
            (Currency::Icn, Currency::Btc) => CurrencyPair::IcnBtc,
            (Currency::Icn, Currency::Eth) => CurrencyPair::IcnEth,
            (Currency::Icx, Currency::Bnb) => CurrencyPair::IcxBnb,
            (Currency::Icx, Currency::Btc) => CurrencyPair::IcxBtc,
            (Currency::Icx, Currency::Eth) => CurrencyPair::IcxEth,
            (Currency::Icx, Currency::Usdt) => CurrencyPair::IcxUsdt,
            (Currency::Ins, Currency::Btc) => CurrencyPair::InsBtc,
            (Currency::Ins, Currency::Eth) => CurrencyPair::InsEth,
            (Currency::Iost, Currency::Bnb) => CurrencyPair::IostBnb,
            (Currency::Iost, Currency::Btc) => CurrencyPair::IostBtc,
            (Currency::Iost, Currency::Eth) => CurrencyPair::IostEth,
            (Currency::Iost, Currency::Usdt) => CurrencyPair::IostUsdt,
            (Currency::Iota, Currency::Bnb) => CurrencyPair::IotaBnb,
            (Currency::Iota, Currency::Btc) => CurrencyPair::IotaBtc,
            (Currency::Iota, Currency::Eth) => CurrencyPair::IotaEth,
            (Currency::Iota, Currency::Usdt) => CurrencyPair::IotaUsdt,
            (Currency::Iotx, Currency::Btc) => CurrencyPair::IotxBtc,
            (Currency::Iotx, Currency::Eth) => CurrencyPair::IotxEth,
            (Currency::Iotx, Currency::Usdt) => CurrencyPair::IotxUsdt,
            (Currency::Kava, Currency::Bnb) => CurrencyPair::KavaBnb,
            (Currency::Kava, Currency::Btc) => CurrencyPair::KavaBtc,
            (Currency::Kava, Currency::Usdt) => CurrencyPair::KavaUsdt,
            (Currency::Key, Currency::Btc) => CurrencyPair::KeyBtc,
            (Currency::Key, Currency::Eth) => CurrencyPair::KeyEth,
            (Currency::Key, Currency::Usdt) => CurrencyPair::KeyUsdt,
            (Currency::Kmd, Currency::Btc) => CurrencyPair::KmdBtc,
            (Currency::Kmd, Currency::Eth) => CurrencyPair::KmdEth,
            (Currency::Knc, Currency::Btc) => CurrencyPair::KncBtc,
            (Currency::Knc, Currency::Eth) => CurrencyPair::KncEth,
            (Currency::Lend, Currency::Btc) => CurrencyPair::LendBtc,
            (Currency::Lend, Currency::Eth) => CurrencyPair::LendEth,
            (Currency::Link, Currency::Btc) => CurrencyPair::LinkBtc,
            (Currency::Link, Currency::Busd) => CurrencyPair::LinkBusd,
            (Currency::Link, Currency::Eth) => CurrencyPair::LinkEth,
            (Currency::Link, Currency::Pax) => CurrencyPair::LinkPax,
            (Currency::Link, Currency::Tusd) => CurrencyPair::LinkTusd,
            (Currency::Link, Currency::Usdc) => CurrencyPair::LinkUsdc,
            (Currency::Link, Currency::Usdt) => CurrencyPair::LinkUsdt,
            (Currency::Loom, Currency::Bnb) => CurrencyPair::LoomBnb,
            (Currency::Loom, Currency::Btc) => CurrencyPair::LoomBtc,
            (Currency::Loom, Currency::Eth) => CurrencyPair::LoomEth,
            (Currency::Lrc, Currency::Btc) => CurrencyPair::LrcBtc,
            (Currency::Lrc, Currency::Eth) => CurrencyPair::LrcEth,
            (Currency::Lsk, Currency::Bnb) => CurrencyPair::LskBnb,
            (Currency::Lsk, Currency::Btc) => CurrencyPair::LskBtc,
            (Currency::Lsk, Currency::Eth) => CurrencyPair::LskEth,
            (Currency::Ltc, Currency::Bnb) => CurrencyPair::LtcBnb,
            (Currency::Ltc, Currency::Btc) => CurrencyPair::LtcBtc,
            (Currency::Ltc, Currency::Busd) => CurrencyPair::LtcBusd,
            (Currency::Ltc, Currency::Eth) => CurrencyPair::LtcEth,
            (Currency::Ltc, Currency::Pax) => CurrencyPair::LtcPax,
            (Currency::Ltc, Currency::Tusd) => CurrencyPair::LtcTusd,
            (Currency::Ltc, Currency::Usdc) => CurrencyPair::LtcUsdc,
            (Currency::Ltc, Currency::Usdt) => CurrencyPair::LtcUsdt,
            (Currency::Lun, Currency::Btc) => CurrencyPair::LunBtc,
            (Currency::Lun, Currency::Eth) => CurrencyPair::LunEth,
            (Currency::Mana, Currency::Btc) => CurrencyPair::ManaBtc,
            (Currency::Mana, Currency::Eth) => CurrencyPair::ManaEth,
            (Currency::Matic, Currency::Bnb) => CurrencyPair::MaticBnb,
            (Currency::Matic, Currency::Btc) => CurrencyPair::MaticBtc,
            (Currency::Matic, Currency::Usdt) => CurrencyPair::MaticUsdt,
            (Currency::Mco, Currency::Bnb) => CurrencyPair::McoBnb,
            (Currency::Mco, Currency::Btc) => CurrencyPair::McoBtc,
            (Currency::Mco, Currency::Eth) => CurrencyPair::McoEth,
            (Currency::Mco, Currency::Usdt) => CurrencyPair::McoUsdt,
            (Currency::Mda, Currency::Btc) => CurrencyPair::MdaBtc,
            (Currency::Mda, Currency::Eth) => CurrencyPair::MdaEth,
            (Currency::Mft, Currency::Bnb) => CurrencyPair::MftBnb,
            (Currency::Mft, Currency::Btc) => CurrencyPair::MftBtc,
            (Currency::Mft, Currency::Eth) => CurrencyPair::MftEth,
            (Currency::Mft, Currency::Usdt) => CurrencyPair::MftUsdt,
            (Currency::Mith, Currency::Bnb) => CurrencyPair::MithBnb,
            (Currency::Mith, Currency::Btc) => CurrencyPair::MithBtc,
            (Currency::Mith, Currency::Usdt) => CurrencyPair::MithUsdt,
            (Currency::Mod, Currency::Btc) => CurrencyPair::ModBtc,
            (Currency::Mod, Currency::Eth) => CurrencyPair::ModEth,
            (Currency::Mth, Currency::Btc) => CurrencyPair::MthBtc,
            (Currency::Mth, Currency::Eth) => CurrencyPair::MthEth,
            (Currency::Mtl, Currency::Btc) => CurrencyPair::MtlBtc,
            (Currency::Mtl, Currency::Eth) => CurrencyPair::MtlEth,
            (Currency::Mtl, Currency::Usdt) => CurrencyPair::MtlUsdt,
            (Currency::Nano, Currency::Bnb) => CurrencyPair::NanoBnb,
            (Currency::Nano, Currency::Btc) => CurrencyPair::NanoBtc,
            (Currency::Nano, Currency::Eth) => CurrencyPair::NanoEth,
            (Currency::Nano, Currency::Usdt) => CurrencyPair::NanoUsdt,
            (Currency::Nas, Currency::Bnb) => CurrencyPair::NasBnb,
            (Currency::Nas, Currency::Btc) => CurrencyPair::NasBtc,
            (Currency::Nas, Currency::Eth) => CurrencyPair::NasEth,
            (Currency::Nav, Currency::Bnb) => CurrencyPair::NavBnb,
            (Currency::Nav, Currency::Btc) => CurrencyPair::NavBtc,
            (Currency::Nav, Currency::Eth) => CurrencyPair::NavEth,
            (Currency::Ncash, Currency::Bnb) => CurrencyPair::NcashBnb,
            (Currency::Ncash, Currency::Btc) => CurrencyPair::NcashBtc,
            (Currency::Ncash, Currency::Eth) => CurrencyPair::NcashEth,
            (Currency::Nebl, Currency::Bnb) => CurrencyPair::NeblBnb,
            (Currency::Nebl, Currency::Btc) => CurrencyPair::NeblBtc,
            (Currency::Nebl, Currency::Eth) => CurrencyPair::NeblEth,
            (Currency::Neo, Currency::Bnb) => CurrencyPair::NeoBnb,
            (Currency::Neo, Currency::Btc) => CurrencyPair::NeoBtc,
            (Currency::Neo, Currency::Eth) => CurrencyPair::NeoEth,
            (Currency::Neo, Currency::Pax) => CurrencyPair::NeoPax,
            (Currency::Neo, Currency::Tusd) => CurrencyPair::NeoTusd,
            (Currency::Neo, Currency::Usdc) => CurrencyPair::NeoUsdc,
            (Currency::Neo, Currency::Usdt) => CurrencyPair::NeoUsdt,
            (Currency::Nkn, Currency::Bnb) => CurrencyPair::NknBnb,
            (Currency::Nkn, Currency::Btc) => CurrencyPair::NknBtc,
            (Currency::Nkn, Currency::Usdt) => CurrencyPair::NknUsdt,
            (Currency::Npxs, Currency::Btc) => CurrencyPair::NpxsBtc,
            (Currency::Npxs, Currency::Eth) => CurrencyPair::NpxsEth,
            (Currency::Npxs, Currency::Usdc) => CurrencyPair::NpxsUsdc,
            (Currency::Npxs, Currency::Usdt) => CurrencyPair::NpxsUsdt,
            (Currency::Nuls, Currency::Bnb) => CurrencyPair::NulsBnb,
            (Currency::Nuls, Currency::Btc) => CurrencyPair::NulsBtc,
            (Currency::Nuls, Currency::Eth) => CurrencyPair::NulsEth,
            (Currency::Nuls, Currency::Usdt) => CurrencyPair::NulsUsdt,
            (Currency::Nxs, Currency::Bnb) => CurrencyPair::NxsBnb,
            (Currency::Nxs, Currency::Btc) => CurrencyPair::NxsBtc,
            (Currency::Nxs, Currency::Eth) => CurrencyPair::NxsEth,
            (Currency::Oax, Currency::Btc) => CurrencyPair::OaxBtc,
            (Currency::Oax, Currency::Eth) => CurrencyPair::OaxEth,
            (Currency::Omg, Currency::Bnb) => CurrencyPair::OmgBnb,
            (Currency::Omg, Currency::Btc) => CurrencyPair::OmgBtc,
            (Currency::Omg, Currency::Eth) => CurrencyPair::OmgEth,
            (Currency::Omg, Currency::Usdt) => CurrencyPair::OmgUsdt,
            (Currency::One, Currency::Bnb) => CurrencyPair::OneBnb,
            (Currency::One, Currency::Btc) => CurrencyPair::OneBtc,
            (Currency::One, Currency::Pax) => CurrencyPair::OnePax,
            (Currency::One, Currency::Tusd) => CurrencyPair::OneTusd,
            (Currency::One, Currency::Usdc) => CurrencyPair::OneUsdc,
            (Currency::One, Currency::Usdt) => CurrencyPair::OneUsdt,
            (Currency::Ong, Currency::Bnb) => CurrencyPair::OngBnb,
            (Currency::Ong, Currency::Btc) => CurrencyPair::OngBtc,
            (Currency::Ong, Currency::Usdt) => CurrencyPair::OngUsdt,
            (Currency::Ont, Currency::Bnb) => CurrencyPair::OntBnb,
            (Currency::Ont, Currency::Btc) => CurrencyPair::OntBtc,
            (Currency::Ont, Currency::Eth) => CurrencyPair::OntEth,
            (Currency::Ont, Currency::Pax) => CurrencyPair::OntPax,
            (Currency::Ont, Currency::Usdc) => CurrencyPair::OntUsdc,
            (Currency::Ont, Currency::Usdt) => CurrencyPair::OntUsdt,
            (Currency::Ost, Currency::Bnb) => CurrencyPair::OstBnb,
            (Currency::Ost, Currency::Btc) => CurrencyPair::OstBtc,
            (Currency::Ost, Currency::Eth) => CurrencyPair::OstEth,
            (Currency::Pax, Currency::Bnb) => CurrencyPair::PaxBnb,
            (Currency::Pax, Currency::Btc) => CurrencyPair::PaxBtc,
            (Currency::Pax, Currency::Eth) => CurrencyPair::PaxEth,
            (Currency::Pax, Currency::Tusd) => CurrencyPair::PaxTusd,
            (Currency::Pax, Currency::Usdt) => CurrencyPair::PaxUsdt,
            (Currency::Perl, Currency::Bnb) => CurrencyPair::PerlBnb,
            (Currency::Perl, Currency::Btc) => CurrencyPair::PerlBtc,
            (Currency::Perl, Currency::Usdc) => CurrencyPair::PerlUsdc,
            (Currency::Perl, Currency::Usdt) => CurrencyPair::PerlUsdt,
            (Currency::Phb, Currency::Bnb) => CurrencyPair::PhbBnb,
            (Currency::Phb, Currency::Btc) => CurrencyPair::PhbBtc,
            (Currency::Phb, Currency::Pax) => CurrencyPair::PhbPax,
            (Currency::Phb, Currency::Tusd) => CurrencyPair::PhbTusd,
            (Currency::Phb, Currency::Usdc) => CurrencyPair::PhbUsdc,
            (Currency::Phx, Currency::Bnb) => CurrencyPair::PhxBnb,
            (Currency::Phx, Currency::Btc) => CurrencyPair::PhxBtc,
            (Currency::Phx, Currency::Eth) => CurrencyPair::PhxEth,
            (Currency::Pivx, Currency::Bnb) => CurrencyPair::PivxBnb,
            (Currency::Pivx, Currency::Btc) => CurrencyPair::PivxBtc,
            (Currency::Pivx, Currency::Eth) => CurrencyPair::PivxEth,
            (Currency::Poa, Currency::Bnb) => CurrencyPair::PoaBnb,
            (Currency::Poa, Currency::Btc) => CurrencyPair::PoaBtc,
            (Currency::Poa, Currency::Eth) => CurrencyPair::PoaEth,
            (Currency::Poe, Currency::Btc) => CurrencyPair::PoeBtc,
            (Currency::Poe, Currency::Eth) => CurrencyPair::PoeEth,
            (Currency::Poly, Currency::Bnb) => CurrencyPair::PolyBnb,
            (Currency::Poly, Currency::Btc) => CurrencyPair::PolyBtc,
            (Currency::Powr, Currency::Bnb) => CurrencyPair::PowrBnb,
            (Currency::Powr, Currency::Btc) => CurrencyPair::PowrBtc,
            (Currency::Powr, Currency::Eth) => CurrencyPair::PowrEth,
            (Currency::Ppt, Currency::Btc) => CurrencyPair::PptBtc,
            (Currency::Ppt, Currency::Eth) => CurrencyPair::PptEth,
            (Currency::Qkc, Currency::Btc) => CurrencyPair::QkcBtc,
            (Currency::Qkc, Currency::Eth) => CurrencyPair::QkcEth,
            (Currency::Qlc, Currency::Bnb) => CurrencyPair::QlcBnb,
            (Currency::Qlc, Currency::Btc) => CurrencyPair::QlcBtc,
            (Currency::Qlc, Currency::Eth) => CurrencyPair::QlcEth,
            (Currency::Qsp, Currency::Bnb) => CurrencyPair::QspBnb,
            (Currency::Qsp, Currency::Btc) => CurrencyPair::QspBtc,
            (Currency::Qsp, Currency::Eth) => CurrencyPair::QspEth,
            (Currency::Qtum, Currency::Bnb) => CurrencyPair::QtumBnb,
            (Currency::Qtum, Currency::Btc) => CurrencyPair::QtumBtc,
            (Currency::Qtum, Currency::Busd) => CurrencyPair::QtumBusd,
            (Currency::Qtum, Currency::Eth) => CurrencyPair::QtumEth,
            (Currency::Qtum, Currency::Usdt) => CurrencyPair::QtumUsdt,
            (Currency::Rcn, Currency::Bnb) => CurrencyPair::RcnBnb,
            (Currency::Rcn, Currency::Btc) => CurrencyPair::RcnBtc,
            (Currency::Rcn, Currency::Eth) => CurrencyPair::RcnEth,
            (Currency::Rdn, Currency::Bnb) => CurrencyPair::RdnBnb,
            (Currency::Rdn, Currency::Btc) => CurrencyPair::RdnBtc,
            (Currency::Rdn, Currency::Eth) => CurrencyPair::RdnEth,
            (Currency::Ren, Currency::Bnb) => CurrencyPair::RenBnb,
            (Currency::Ren, Currency::Btc) => CurrencyPair::RenBtc,
            (Currency::Ren, Currency::Usdt) => CurrencyPair::RenUsdt,
            (Currency::Rep, Currency::Bnb) => CurrencyPair::RepBnb,
            (Currency::Rep, Currency::Btc) => CurrencyPair::RepBtc,
            (Currency::Rep, Currency::Eth) => CurrencyPair::RepEth,
            (Currency::Req, Currency::Btc) => CurrencyPair::ReqBtc,
            (Currency::Req, Currency::Eth) => CurrencyPair::ReqEth,
            (Currency::Rlc, Currency::Bnb) => CurrencyPair::RlcBnb,
            (Currency::Rlc, Currency::Btc) => CurrencyPair::RlcBtc,
            (Currency::Rlc, Currency::Eth) => CurrencyPair::RlcEth,
            (Currency::Rlc, Currency::Usdt) => CurrencyPair::RlcUsdt,
            (Currency::Rpx, Currency::Bnb) => CurrencyPair::RpxBnb,
            (Currency::Rpx, Currency::Btc) => CurrencyPair::RpxBtc,
            (Currency::Rpx, Currency::Eth) => CurrencyPair::RpxEth,
            (Currency::Rvn, Currency::Bnb) => CurrencyPair::RvnBnb,
            (Currency::Rvn, Currency::Btc) => CurrencyPair::RvnBtc,
            (Currency::Rvn, Currency::Usdt) => CurrencyPair::RvnUsdt,
            (Currency::Salt, Currency::Btc) => CurrencyPair::SaltBtc,
            (Currency::Salt, Currency::Eth) => CurrencyPair::SaltEth,
            (Currency::Sc, Currency::Bnb) => CurrencyPair::ScBnb,
            (Currency::Sc, Currency::Btc) => CurrencyPair::ScBtc,
            (Currency::Sc, Currency::Eth) => CurrencyPair::ScEth,
            (Currency::Sky, Currency::Bnb) => CurrencyPair::SkyBnb,
            (Currency::Sky, Currency::Btc) => CurrencyPair::SkyBtc,
            (Currency::Sky, Currency::Eth) => CurrencyPair::SkyEth,
            (Currency::Sngls, Currency::Btc) => CurrencyPair::SnglsBtc,
            (Currency::Sngls, Currency::Eth) => CurrencyPair::SnglsEth,
            (Currency::Snm, Currency::Btc) => CurrencyPair::SnmBtc,
            (Currency::Snm, Currency::Eth) => CurrencyPair::SnmEth,
            (Currency::Snt, Currency::Btc) => CurrencyPair::SntBtc,
            (Currency::Snt, Currency::Eth) => CurrencyPair::SntEth,
            (Currency::Steem, Currency::Bnb) => CurrencyPair::SteemBnb,
            (Currency::Steem, Currency::Btc) => CurrencyPair::SteemBtc,
            (Currency::Steem, Currency::Eth) => CurrencyPair::SteemEth,
            (Currency::Storj, Currency::Btc) => CurrencyPair::StorjBtc,
            (Currency::Storj, Currency::Eth) => CurrencyPair::StorjEth,
            (Currency::Storm, Currency::Bnb) => CurrencyPair::StormBnb,
            (Currency::Storm, Currency::Btc) => CurrencyPair::StormBtc,
            (Currency::Storm, Currency::Eth) => CurrencyPair::StormEth,
            (Currency::Storm, Currency::Usdt) => CurrencyPair::StormUsdt,
            (Currency::Strat, Currency::Btc) => CurrencyPair::StratBtc,
            (Currency::Strat, Currency::Eth) => CurrencyPair::StratEth,
            (Currency::Stx, Currency::Bnb) => CurrencyPair::StxBnb,
            (Currency::Stx, Currency::Btc) => CurrencyPair::StxBtc,
            (Currency::Stx, Currency::Usdt) => CurrencyPair::StxUsdt,
            (Currency::Sub, Currency::Btc) => CurrencyPair::SubBtc,
            (Currency::Sub, Currency::Eth) => CurrencyPair::SubEth,
            (Currency::Sys, Currency::Bnb) => CurrencyPair::SysBnb,
            (Currency::Sys, Currency::Btc) => CurrencyPair::SysBtc,
            (Currency::Sys, Currency::Eth) => CurrencyPair::SysEth,
            (Currency::Tfuel, Currency::Bnb) => CurrencyPair::TfuelBnb,
            (Currency::Tfuel, Currency::Btc) => CurrencyPair::TfuelBtc,
            (Currency::Tfuel, Currency::Pax) => CurrencyPair::TfuelPax,
            (Currency::Tfuel, Currency::Tusd) => CurrencyPair::TfuelTusd,
            (Currency::Tfuel, Currency::Usdc) => CurrencyPair::TfuelUsdc,
            (Currency::Tfuel, Currency::Usdt) => CurrencyPair::TfuelUsdt,
            (Currency::Theta, Currency::Bnb) => CurrencyPair::ThetaBnb,
            (Currency::Theta, Currency::Btc) => CurrencyPair::ThetaBtc,
            (Currency::Theta, Currency::Eth) => CurrencyPair::ThetaEth,
            (Currency::Theta, Currency::Usdt) => CurrencyPair::ThetaUsdt,
            (Currency::Tnb, Currency::Btc) => CurrencyPair::TnbBtc,
            (Currency::Tnb, Currency::Eth) => CurrencyPair::TnbEth,
            (Currency::Tnt, Currency::Btc) => CurrencyPair::TntBtc,
            (Currency::Tnt, Currency::Eth) => CurrencyPair::TntEth,
            (Currency::Tomo, Currency::Bnb) => CurrencyPair::TomoBnb,
            (Currency::Tomo, Currency::Btc) => CurrencyPair::TomoBtc,
            (Currency::Tomo, Currency::Usdc) => CurrencyPair::TomoUsdc,
            (Currency::Tomo, Currency::Usdt) => CurrencyPair::TomoUsdt,
            (Currency::Trig, Currency::Bnb) => CurrencyPair::TrigBnb,
            (Currency::Trig, Currency::Btc) => CurrencyPair::TrigBtc,
            (Currency::Trig, Currency::Eth) => CurrencyPair::TrigEth,
            (Currency::Troy, Currency::Bnb) => CurrencyPair::TroyBnb,
            (Currency::Troy, Currency::Btc) => CurrencyPair::TroyBtc,
            (Currency::Troy, Currency::Usdt) => CurrencyPair::TroyUsdt,
            (Currency::Trx, Currency::Bnb) => CurrencyPair::TrxBnb,
            (Currency::Trx, Currency::Btc) => CurrencyPair::TrxBtc,
            (Currency::Trx, Currency::Busd) => CurrencyPair::TrxBusd,
            (Currency::Trx, Currency::Eth) => CurrencyPair::TrxEth,
            (Currency::Trx, Currency::Pax) => CurrencyPair::TrxPax,
            (Currency::Trx, Currency::Tusd) => CurrencyPair::TrxTusd,
            (Currency::Trx, Currency::Usdc) => CurrencyPair::TrxUsdc,
            (Currency::Trx, Currency::Usdt) => CurrencyPair::TrxUsdt,
            (Currency::Trx, Currency::Xrp) => CurrencyPair::TrxXrp,
            (Currency::Tusdb, Currency::Tusd) => CurrencyPair::TusdbTusd,
            (Currency::Tusd, Currency::Bnb) => CurrencyPair::TusdBnb,
            (Currency::Tusd, Currency::Btc) => CurrencyPair::TusdBtc,
            (Currency::Tusd, Currency::Eth) => CurrencyPair::TusdEth,
            (Currency::Tusd, Currency::Usdt) => CurrencyPair::TusdUsdt,
            (Currency::Usdc, Currency::Bnb) => CurrencyPair::UsdcBnb,
            (Currency::Usdc, Currency::Dash) => CurrencyPair::UsdcDash,
            (Currency::Usdc, Currency::Grin) => CurrencyPair::UsdcGrin,
            (Currency::Usdc, Currency::Pax) => CurrencyPair::UsdcPax,
            (Currency::Usdc, Currency::Str) => CurrencyPair::UsdcStr,
            (Currency::Usdc, Currency::Tusd) => CurrencyPair::UsdcTusd,
            (Currency::Usdc, Currency::Usdt) => CurrencyPair::UsdcUsdt,
            (Currency::Usdc, Currency::Xmr) => CurrencyPair::UsdcXmr,
            (Currency::Usdsb, Currency::Usds) => CurrencyPair::UsdsbUsds,
            (Currency::Usdsb, Currency::Usdt) => CurrencyPair::UsdsbUsdt,
            (Currency::Usds, Currency::Pax) => CurrencyPair::UsdsPax,
            (Currency::Usds, Currency::Tusd) => CurrencyPair::UsdsTusd,
            (Currency::Usds, Currency::Usdc) => CurrencyPair::UsdsUsdc,
            (Currency::Usds, Currency::Usdt) => CurrencyPair::UsdsUsdt,
            (Currency::Usdt, Currency::Dgb) => CurrencyPair::UsdtDgb,
            (Currency::Usdt, Currency::Gnt) => CurrencyPair::UsdtGnt,
            (Currency::Usdt, Currency::Grin) => CurrencyPair::UsdtGrin,
            (Currency::Usdt, Currency::Lsk) => CurrencyPair::UsdtLsk,
            (Currency::Usdt, Currency::Mana) => CurrencyPair::UsdtMana,
            (Currency::Usdt, Currency::Nxt) => CurrencyPair::UsdtNxt,
            (Currency::Usdt, Currency::Rep) => CurrencyPair::UsdtRep,
            (Currency::Usdt, Currency::Rub) => CurrencyPair::UsdtRub,
            (Currency::Usdt, Currency::Sc) => CurrencyPair::UsdtSc,
            (Currency::Usdt, Currency::Str) => CurrencyPair::UsdtStr,
            (Currency::Usdt, Currency::Try) => CurrencyPair::UsdtTry,
            (Currency::Ven, Currency::Bnb) => CurrencyPair::VenBnb,
            (Currency::Ven, Currency::Btc) => CurrencyPair::VenBtc,
            (Currency::Ven, Currency::Eth) => CurrencyPair::VenEth,
            (Currency::Ven, Currency::Usdt) => CurrencyPair::VenUsdt,
            (Currency::Vet, Currency::Bnb) => CurrencyPair::VetBnb,
            (Currency::Vet, Currency::Btc) => CurrencyPair::VetBtc,
            (Currency::Vet, Currency::Busd) => CurrencyPair::VetBusd,
            (Currency::Vet, Currency::Eth) => CurrencyPair::VetEth,
            (Currency::Vet, Currency::Usdt) => CurrencyPair::VetUsdt,
            (Currency::Via, Currency::Bnb) => CurrencyPair::ViaBnb,
            (Currency::Via, Currency::Btc) => CurrencyPair::ViaBtc,
            (Currency::Via, Currency::Eth) => CurrencyPair::ViaEth,
            (Currency::Vibe, Currency::Btc) => CurrencyPair::VibeBtc,
            (Currency::Vibe, Currency::Eth) => CurrencyPair::VibeEth,
            (Currency::Vib, Currency::Btc) => CurrencyPair::VibBtc,
            (Currency::Vib, Currency::Eth) => CurrencyPair::VibEth,
            (Currency::Vite, Currency::Bnb) => CurrencyPair::ViteBnb,
            (Currency::Vite, Currency::Btc) => CurrencyPair::ViteBtc,
            (Currency::Vite, Currency::Usdt) => CurrencyPair::ViteUsdt,
            (Currency::Wabi, Currency::Bnb) => CurrencyPair::WabiBnb,
            (Currency::Wabi, Currency::Btc) => CurrencyPair::WabiBtc,
            (Currency::Wabi, Currency::Eth) => CurrencyPair::WabiEth,
            (Currency::Wan, Currency::Bnb) => CurrencyPair::WanBnb,
            (Currency::Wan, Currency::Btc) => CurrencyPair::WanBtc,
            (Currency::Wan, Currency::Eth) => CurrencyPair::WanEth,
            (Currency::Wan, Currency::Usdt) => CurrencyPair::WanUsdt,
            (Currency::Waves, Currency::Bnb) => CurrencyPair::WavesBnb,
            (Currency::Waves, Currency::Btc) => CurrencyPair::WavesBtc,
            (Currency::Waves, Currency::Eth) => CurrencyPair::WavesEth,
            (Currency::Waves, Currency::Pax) => CurrencyPair::WavesPax,
            (Currency::Waves, Currency::Tusd) => CurrencyPair::WavesTusd,
            (Currency::Waves, Currency::Usdc) => CurrencyPair::WavesUsdc,
            (Currency::Waves, Currency::Usdt) => CurrencyPair::WavesUsdt,
            (Currency::Wings, Currency::Btc) => CurrencyPair::WingsBtc,
            (Currency::Wings, Currency::Eth) => CurrencyPair::WingsEth,
            (Currency::Win, Currency::Bnb) => CurrencyPair::WinBnb,
            (Currency::Win, Currency::Btc) => CurrencyPair::WinBtc,
            (Currency::Win, Currency::Trx) => CurrencyPair::WinTrx,
            (Currency::Win, Currency::Usdc) => CurrencyPair::WinUsdc,
            (Currency::Win, Currency::Usdt) => CurrencyPair::WinUsdt,
            (Currency::Wpr, Currency::Btc) => CurrencyPair::WprBtc,
            (Currency::Wpr, Currency::Eth) => CurrencyPair::WprEth,
            (Currency::Wtc, Currency::Bnb) => CurrencyPair::WtcBnb,
            (Currency::Wtc, Currency::Btc) => CurrencyPair::WtcBtc,
            (Currency::Wtc, Currency::Eth) => CurrencyPair::WtcEth,
            (Currency::Xem, Currency::Bnb) => CurrencyPair::XemBnb,
            (Currency::Xem, Currency::Btc) => CurrencyPair::XemBtc,
            (Currency::Xem, Currency::Eth) => CurrencyPair::XemEth,
            (Currency::Xlm, Currency::Bnb) => CurrencyPair::XlmBnb,
            (Currency::Xlm, Currency::Btc) => CurrencyPair::XlmBtc,
            (Currency::Xlm, Currency::Busd) => CurrencyPair::XlmBusd,
            (Currency::Xlm, Currency::Eth) => CurrencyPair::XlmEth,
            (Currency::Xlm, Currency::Pax) => CurrencyPair::XlmPax,
            (Currency::Xlm, Currency::Tusd) => CurrencyPair::XlmTusd,
            (Currency::Xlm, Currency::Usdc) => CurrencyPair::XlmUsdc,
            (Currency::Xlm, Currency::Usdt) => CurrencyPair::XlmUsdt,
            (Currency::Xmr, Currency::Bnb) => CurrencyPair::XmrBnb,
            (Currency::Xmr, Currency::Btc) => CurrencyPair::XmrBtc,
            (Currency::Xmr, Currency::Eth) => CurrencyPair::XmrEth,
            (Currency::Xmr, Currency::Usdt) => CurrencyPair::XmrUsdt,
            (Currency::Xrp, Currency::Bnb) => CurrencyPair::XrpBnb,
            (Currency::Xrp, Currency::Btc) => CurrencyPair::XrpBtc,
            (Currency::Xrp, Currency::Busd) => CurrencyPair::XrpBusd,
            (Currency::Xrp, Currency::Eth) => CurrencyPair::XrpEth,
            (Currency::Xrp, Currency::Pax) => CurrencyPair::XrpPax,
            (Currency::Xrp, Currency::Rub) => CurrencyPair::XrpRub,
            (Currency::Xrp, Currency::Try) => CurrencyPair::XrpTry,
            (Currency::Xrp, Currency::Tusd) => CurrencyPair::XrpTusd,
            (Currency::Xrp, Currency::Usdc) => CurrencyPair::XrpUsdc,
            (Currency::Xrp, Currency::Usdt) => CurrencyPair::XrpUsdt,
            (Currency::Xtz, Currency::Bnb) => CurrencyPair::XtzBnb,
            (Currency::Xtz, Currency::Btc) => CurrencyPair::XtzBtc,
            (Currency::Xtz, Currency::Usdt) => CurrencyPair::XtzUsdt,
            (Currency::Xvg, Currency::Btc) => CurrencyPair::XvgBtc,
            (Currency::Xvg, Currency::Eth) => CurrencyPair::XvgEth,
            (Currency::Xzc, Currency::Bnb) => CurrencyPair::XzcBnb,
            (Currency::Xzc, Currency::Btc) => CurrencyPair::XzcBtc,
            (Currency::Xzc, Currency::Eth) => CurrencyPair::XzcEth,
            (Currency::Xzc, Currency::Xrp) => CurrencyPair::XzcXrp,
            (Currency::Yoyo, Currency::Bnb) => CurrencyPair::YoyoBnb,
            (Currency::Yoyo, Currency::Btc) => CurrencyPair::YoyoBtc,
            (Currency::Yoyo, Currency::Eth) => CurrencyPair::YoyoEth,
            (Currency::Zec, Currency::Bnb) => CurrencyPair::ZecBnb,
            (Currency::Zec, Currency::Btc) => CurrencyPair::ZecBtc,
            (Currency::Zec, Currency::Eth) => CurrencyPair::ZecEth,
            (Currency::Zec, Currency::Pax) => CurrencyPair::ZecPax,
            (Currency::Zec, Currency::Tusd) => CurrencyPair::ZecTusd,
            (Currency::Zec, Currency::Usdc) => CurrencyPair::ZecUsdc,
            (Currency::Zec, Currency::Usdt) => CurrencyPair::ZecUsdt,
            (Currency::Zen, Currency::Bnb) => CurrencyPair::ZenBnb,
            (Currency::Zen, Currency::Btc) => CurrencyPair::ZenBtc,
            (Currency::Zen, Currency::Eth) => CurrencyPair::ZenEth,
            (Currency::Zil, Currency::Bnb) => CurrencyPair::ZilBnb,
            (Currency::Zil, Currency::Btc) => CurrencyPair::ZilBtc,
            (Currency::Zil, Currency::Eth) => CurrencyPair::ZilEth,
            (Currency::Zil, Currency::Usdt) => CurrencyPair::ZilUsdt,
            (Currency::Zrx, Currency::Bnb) => CurrencyPair::ZrxBnb,
            (Currency::Zrx, Currency::Btc) => CurrencyPair::ZrxBtc,
            (Currency::Zrx, Currency::Eth) => CurrencyPair::ZrxEth,
            (Currency::Zrx, Currency::Usdt) => CurrencyPair::ZrxUsdt,
            (quote, base) => CurrencyPair::Custom(format!("{}_{}", quote, base), quote, base),
        }
    }

    pub fn split_reversed(pair: &str) -> Result<CurrencyPair, Error> {
        match pair {
            "BNB_ADA" => Ok(CurrencyPair::AdaBnb),
            "BTC_ADA" => Ok(CurrencyPair::AdaBtc),
            "BUSD_ADA" => Ok(CurrencyPair::AdaBusd),
            "ETH_ADA" => Ok(CurrencyPair::AdaEth),
            "PAX_ADA" => Ok(CurrencyPair::AdaPax),
            "TUSD_ADA" => Ok(CurrencyPair::AdaTusd),
            "USDC_ADA" => Ok(CurrencyPair::AdaUsdc),
            "USDT_ADA" => Ok(CurrencyPair::AdaUsdt),
            "BNB_ADX" => Ok(CurrencyPair::AdxBnb),
            "BTC_ADX" => Ok(CurrencyPair::AdxBtc),
            "ETH_ADX" => Ok(CurrencyPair::AdxEth),
            "BNB_AE" => Ok(CurrencyPair::AeBnb),
            "BTC_AE" => Ok(CurrencyPair::AeBtc),
            "ETH_AE" => Ok(CurrencyPair::AeEth),
            "BNB_AGI" => Ok(CurrencyPair::AgiBnb),
            "BTC_AGI" => Ok(CurrencyPair::AgiBtc),
            "ETH_AGI" => Ok(CurrencyPair::AgiEth),
            "BNB_AION" => Ok(CurrencyPair::AionBnb),
            "BTC_AION" => Ok(CurrencyPair::AionBtc),
            "ETH_AION" => Ok(CurrencyPair::AionEth),
            "BNB_ALGO" => Ok(CurrencyPair::AlgoBnb),
            "BTC_ALGO" => Ok(CurrencyPair::AlgoBtc),
            "PAX_ALGO" => Ok(CurrencyPair::AlgoPax),
            "TUSD_ALGO" => Ok(CurrencyPair::AlgoTusd),
            "USDC_ALGO" => Ok(CurrencyPair::AlgoUsdc),
            "USDT_ALGO" => Ok(CurrencyPair::AlgoUsdt),
            "BNB_AMB" => Ok(CurrencyPair::AmbBnb),
            "BTC_AMB" => Ok(CurrencyPair::AmbBtc),
            "ETH_AMB" => Ok(CurrencyPair::AmbEth),
            "BNB_ANKR" => Ok(CurrencyPair::AnkrBnb),
            "BTC_ANKR" => Ok(CurrencyPair::AnkrBtc),
            "PAX_ANKR" => Ok(CurrencyPair::AnkrPax),
            "TUSD_ANKR" => Ok(CurrencyPair::AnkrTusd),
            "USDC_ANKR" => Ok(CurrencyPair::AnkrUsdc),
            "USDT_ANKR" => Ok(CurrencyPair::AnkrUsdt),
            "BNB_APPC" => Ok(CurrencyPair::AppcBnb),
            "BTC_APPC" => Ok(CurrencyPair::AppcBtc),
            "ETH_APPC" => Ok(CurrencyPair::AppcEth),
            "BNB_ARDR" => Ok(CurrencyPair::ArdrBnb),
            "BTC_ARDR" => Ok(CurrencyPair::ArdrBtc),
            "ETH_ARDR" => Ok(CurrencyPair::ArdrEth),
            "BTC_ARK" => Ok(CurrencyPair::ArkBtc),
            "ETH_ARK" => Ok(CurrencyPair::ArkEth),
            "BTC_ARN" => Ok(CurrencyPair::ArnBtc),
            "ETH_ARN" => Ok(CurrencyPair::ArnEth),
            "BNB_ARPA" => Ok(CurrencyPair::ArpaBnb),
            "BTC_ARPA" => Ok(CurrencyPair::ArpaBtc),
            "USDT_ARPA" => Ok(CurrencyPair::ArpaUsdt),
            "BTC_AST" => Ok(CurrencyPair::AstBtc),
            "ETH_AST" => Ok(CurrencyPair::AstEth),
            "BNB_ATOM" => Ok(CurrencyPair::AtomBnb),
            "BTC_ATOM" => Ok(CurrencyPair::AtomBtc),
            "PAX_ATOM" => Ok(CurrencyPair::AtomPax),
            "TUSD_ATOM" => Ok(CurrencyPair::AtomTusd),
            "USDC_ATOM" => Ok(CurrencyPair::AtomUsdc),
            "USDT_ATOM" => Ok(CurrencyPair::AtomUsdt),
            "BNB_BAND" => Ok(CurrencyPair::BandBnb),
            "BTC_BAND" => Ok(CurrencyPair::BandBtc),
            "USDT_BAND" => Ok(CurrencyPair::BandUsdt),
            "BNB_BAT" => Ok(CurrencyPair::BatBnb),
            "BTC_BAT" => Ok(CurrencyPair::BatBtc),
            "ETH_BAT" => Ok(CurrencyPair::BatEth),
            "PAX_BAT" => Ok(CurrencyPair::BatPax),
            "TUSD_BAT" => Ok(CurrencyPair::BatTusd),
            "USDC_BAT" => Ok(CurrencyPair::BatUsdc),
            "USDT_BAT" => Ok(CurrencyPair::BatUsdt),
            "BNB_BCC" => Ok(CurrencyPair::BccBnb),
            "BTC_BCC" => Ok(CurrencyPair::BccBtc),
            "ETH_BCC" => Ok(CurrencyPair::BccEth),
            "USDT_BCC" => Ok(CurrencyPair::BccUsdt),
            "BTC_BCD" => Ok(CurrencyPair::BcdBtc),
            "ETH_BCD" => Ok(CurrencyPair::BcdEth),
            "BTC_BCHABC" => Ok(CurrencyPair::BchabcBtc),
            "BUSD_BCHABC" => Ok(CurrencyPair::BchabcBusd),
            "PAX_BCHABC" => Ok(CurrencyPair::BchabcPax),
            "TUSD_BCHABC" => Ok(CurrencyPair::BchabcTusd),
            "USDC_BCHABC" => Ok(CurrencyPair::BchabcUsdc),
            "USDT_BCHABC" => Ok(CurrencyPair::BchabcUsdt),
            "BTC_BCHSV" => Ok(CurrencyPair::BchsvBtc),
            "PAX_BCHSV" => Ok(CurrencyPair::BchsvPax),
            "TUSD_BCHSV" => Ok(CurrencyPair::BchsvTusd),
            "USDC_BCHSV" => Ok(CurrencyPair::BchsvUsdc),
            "USDT_BCHSV" => Ok(CurrencyPair::BchsvUsdt),
            "BNB_BCH" => Ok(CurrencyPair::BchBnb),
            "BTC_BCH" => Ok(CurrencyPair::BchBtc),
            "BUSD_BCH" => Ok(CurrencyPair::BchBusd),
            "PAX_BCH" => Ok(CurrencyPair::BchPax),
            "TUSD_BCH" => Ok(CurrencyPair::BchTusd),
            "USDC_BCH" => Ok(CurrencyPair::BchUsdc),
            "USDT_BCH" => Ok(CurrencyPair::BchUsdt),
            "BNB_BCN" => Ok(CurrencyPair::BcnBnb),
            "BTC_BCN" => Ok(CurrencyPair::BcnBtc),
            "ETH_BCN" => Ok(CurrencyPair::BcnEth),
            "BNB_BCPT" => Ok(CurrencyPair::BcptBnb),
            "BTC_BCPT" => Ok(CurrencyPair::BcptBtc),
            "ETH_BCPT" => Ok(CurrencyPair::BcptEth),
            "PAX_BCPT" => Ok(CurrencyPair::BcptPax),
            "TUSD_BCPT" => Ok(CurrencyPair::BcptTusd),
            "USDC_BCPT" => Ok(CurrencyPair::BcptUsdc),
            "BNB_BEAM" => Ok(CurrencyPair::BeamBnb),
            "BTC_BEAM" => Ok(CurrencyPair::BeamBtc),
            "USDT_BEAM" => Ok(CurrencyPair::BeamUsdt),
            "USDC_BGBP" => Ok(CurrencyPair::BgbpUsdc),
            "BNB_BLZ" => Ok(CurrencyPair::BlzBnb),
            "BTC_BLZ" => Ok(CurrencyPair::BlzBtc),
            "ETH_BLZ" => Ok(CurrencyPair::BlzEth),
            "BTC_BNB" => Ok(CurrencyPair::BnbBtc),
            "BUSD_BNB" => Ok(CurrencyPair::BnbBusd),
            "ETH_BNB" => Ok(CurrencyPair::BnbEth),
            "NGN_BNB" => Ok(CurrencyPair::BnbNgn),
            "PAX_BNB" => Ok(CurrencyPair::BnbPax),
            "RUB_BNB" => Ok(CurrencyPair::BnbRub),
            "TRY_BNB" => Ok(CurrencyPair::BnbTry),
            "TUSD_BNB" => Ok(CurrencyPair::BnbTusd),
            "USDC_BNB" => Ok(CurrencyPair::BnbUsdc),
            "USDS_BNB" => Ok(CurrencyPair::BnbUsds),
            "USDT_BNB" => Ok(CurrencyPair::BnbUsdt),
            "BTC_BNT" => Ok(CurrencyPair::BntBtc),
            "ETH_BNT" => Ok(CurrencyPair::BntEth),
            "BTC_BQX" => Ok(CurrencyPair::BqxBtc),
            "ETH_BQX" => Ok(CurrencyPair::BqxEth),
            "BNB_BRD" => Ok(CurrencyPair::BrdBnb),
            "BTC_BRD" => Ok(CurrencyPair::BrdBtc),
            "ETH_BRD" => Ok(CurrencyPair::BrdEth),
            "BTC_BTCB" => Ok(CurrencyPair::BtcbBtc),
            "BUSD_BTC" => Ok(CurrencyPair::BtcBusd),
            "DGB_BTC" => Ok(CurrencyPair::BtcDgb),
            "FCT_BTC" => Ok(CurrencyPair::BtcFct),
            "FOAM_BTC" => Ok(CurrencyPair::BtcFoam),
            "GRIN_BTC" => Ok(CurrencyPair::BtcGrin),
            "LPT_BTC" => Ok(CurrencyPair::BtcLpt),
            "MAID_BTC" => Ok(CurrencyPair::BtcMaid),
            "NGN_BTC" => Ok(CurrencyPair::BtcNgn),
            "NMR_BTC" => Ok(CurrencyPair::BtcNmr),
            "NXT_BTC" => Ok(CurrencyPair::BtcNxt),
            "OMNI_BTC" => Ok(CurrencyPair::BtcOmni),
            "PAX_BTC" => Ok(CurrencyPair::BtcPax),
            "RUB_BTC" => Ok(CurrencyPair::BtcRub),
            "STR_BTC" => Ok(CurrencyPair::BtcStr),
            "TRY_BTC" => Ok(CurrencyPair::BtcTry),
            "TUSD_BTC" => Ok(CurrencyPair::BtcTusd),
            "USDC_BTC" => Ok(CurrencyPair::BtcUsdc),
            "USDS_BTC" => Ok(CurrencyPair::BtcUsds),
            "USDT_BTC" => Ok(CurrencyPair::BtcUsdt),
            "VTC_BTC" => Ok(CurrencyPair::BtcVtc),
            "XPM_BTC" => Ok(CurrencyPair::BtcXpm),
            "BTC_BTG" => Ok(CurrencyPair::BtgBtc),
            "ETH_BTG" => Ok(CurrencyPair::BtgEth),
            "BNB_BTS" => Ok(CurrencyPair::BtsBnb),
            "BTC_BTS" => Ok(CurrencyPair::BtsBtc),
            "ETH_BTS" => Ok(CurrencyPair::BtsEth),
            "BNB_BTT" => Ok(CurrencyPair::BttBnb),
            "BTC_BTT" => Ok(CurrencyPair::BttBtc),
            "PAX_BTT" => Ok(CurrencyPair::BttPax),
            "TRX_BTT" => Ok(CurrencyPair::BttTrx),
            "TUSD_BTT" => Ok(CurrencyPair::BttTusd),
            "USDC_BTT" => Ok(CurrencyPair::BttUsdc),
            "USDT_BTT" => Ok(CurrencyPair::BttUsdt),
            "NGN_BUSD" => Ok(CurrencyPair::BusdNgn),
            "RUB_BUSD" => Ok(CurrencyPair::BusdRub),
            "TRY_BUSD" => Ok(CurrencyPair::BusdTry),
            "USDT_BUSD" => Ok(CurrencyPair::BusdUsdt),
            "BTC_CDT" => Ok(CurrencyPair::CdtBtc),
            "ETH_CDT" => Ok(CurrencyPair::CdtEth),
            "BNB_CELR" => Ok(CurrencyPair::CelrBnb),
            "BTC_CELR" => Ok(CurrencyPair::CelrBtc),
            "USDT_CELR" => Ok(CurrencyPair::CelrUsdt),
            "BTC_CHAT" => Ok(CurrencyPair::ChatBtc),
            "ETH_CHAT" => Ok(CurrencyPair::ChatEth),
            "BNB_CHZ" => Ok(CurrencyPair::ChzBnb),
            "BTC_CHZ" => Ok(CurrencyPair::ChzBtc),
            "USDT_CHZ" => Ok(CurrencyPair::ChzUsdt),
            "BTC_CLOAK" => Ok(CurrencyPair::CloakBtc),
            "ETH_CLOAK" => Ok(CurrencyPair::CloakEth),
            "BNB_CMT" => Ok(CurrencyPair::CmtBnb),
            "BTC_CMT" => Ok(CurrencyPair::CmtBtc),
            "ETH_CMT" => Ok(CurrencyPair::CmtEth),
            "BNB_CND" => Ok(CurrencyPair::CndBnb),
            "BTC_CND" => Ok(CurrencyPair::CndBtc),
            "ETH_CND" => Ok(CurrencyPair::CndEth),
            "BNB_COCOS" => Ok(CurrencyPair::CocosBnb),
            "BTC_COCOS" => Ok(CurrencyPair::CocosBtc),
            "USDT_COCOS" => Ok(CurrencyPair::CocosUsdt),
            "BNB_COS" => Ok(CurrencyPair::CosBnb),
            "BTC_COS" => Ok(CurrencyPair::CosBtc),
            "USDT_COS" => Ok(CurrencyPair::CosUsdt),
            "BNB_CTXC" => Ok(CurrencyPair::CtxcBnb),
            "BTC_CTXC" => Ok(CurrencyPair::CtxcBtc),
            "USDT_CTXC" => Ok(CurrencyPair::CtxcUsdt),
            "BNB_CVC" => Ok(CurrencyPair::CvcBnb),
            "BTC_CVC" => Ok(CurrencyPair::CvcBtc),
            "ETH_CVC" => Ok(CurrencyPair::CvcEth),
            "USDT_CVC" => Ok(CurrencyPair::CvcUsdt),
            "BNB_DASH" => Ok(CurrencyPair::DashBnb),
            "BTC_DASH" => Ok(CurrencyPair::DashBtc),
            "ETH_DASH" => Ok(CurrencyPair::DashEth),
            "USDT_DASH" => Ok(CurrencyPair::DashUsdt),
            "BTC_DATA" => Ok(CurrencyPair::DataBtc),
            "ETH_DATA" => Ok(CurrencyPair::DataEth),
            "BNB_DCR" => Ok(CurrencyPair::DcrBnb),
            "BTC_DCR" => Ok(CurrencyPair::DcrBtc),
            "BTC_DENT" => Ok(CurrencyPair::DentBtc),
            "ETH_DENT" => Ok(CurrencyPair::DentEth),
            "USDT_DENT" => Ok(CurrencyPair::DentUsdt),
            "BTC_DGD" => Ok(CurrencyPair::DgdBtc),
            "ETH_DGD" => Ok(CurrencyPair::DgdEth),
            "BNB_DLT" => Ok(CurrencyPair::DltBnb),
            "BTC_DLT" => Ok(CurrencyPair::DltBtc),
            "ETH_DLT" => Ok(CurrencyPair::DltEth),
            "BTC_DNT" => Ok(CurrencyPair::DntBtc),
            "ETH_DNT" => Ok(CurrencyPair::DntEth),
            "BTC_DOCK" => Ok(CurrencyPair::DockBtc),
            "ETH_DOCK" => Ok(CurrencyPair::DockEth),
            "USDT_DOCK" => Ok(CurrencyPair::DockUsdt),
            "BNB_DOGE" => Ok(CurrencyPair::DogeBnb),
            "BTC_DOGE" => Ok(CurrencyPair::DogeBtc),
            "PAX_DOGE" => Ok(CurrencyPair::DogePax),
            "USDC_DOGE" => Ok(CurrencyPair::DogeUsdc),
            "USDT_DOGE" => Ok(CurrencyPair::DogeUsdt),
            "BNB_DUSK" => Ok(CurrencyPair::DuskBnb),
            "BTC_DUSK" => Ok(CurrencyPair::DuskBtc),
            "PAX_DUSK" => Ok(CurrencyPair::DuskPax),
            "USDC_DUSK" => Ok(CurrencyPair::DuskUsdc),
            "USDT_DUSK" => Ok(CurrencyPair::DuskUsdt),
            "BTC_EDO" => Ok(CurrencyPair::EdoBtc),
            "ETH_EDO" => Ok(CurrencyPair::EdoEth),
            "BTC_ELF" => Ok(CurrencyPair::ElfBtc),
            "ETH_ELF" => Ok(CurrencyPair::ElfEth),
            "BTC_ENG" => Ok(CurrencyPair::EngBtc),
            "ETH_ENG" => Ok(CurrencyPair::EngEth),
            "BNB_ENJ" => Ok(CurrencyPair::EnjBnb),
            "BTC_ENJ" => Ok(CurrencyPair::EnjBtc),
            "ETH_ENJ" => Ok(CurrencyPair::EnjEth),
            "USDT_ENJ" => Ok(CurrencyPair::EnjUsdt),
            "BNB_EOS" => Ok(CurrencyPair::EosBnb),
            "BTC_EOS" => Ok(CurrencyPair::EosBtc),
            "BUSD_EOS" => Ok(CurrencyPair::EosBusd),
            "ETH_EOS" => Ok(CurrencyPair::EosEth),
            "PAX_EOS" => Ok(CurrencyPair::EosPax),
            "TUSD_EOS" => Ok(CurrencyPair::EosTusd),
            "USDC_EOS" => Ok(CurrencyPair::EosUsdc),
            "USDT_EOS" => Ok(CurrencyPair::EosUsdt),
            "BNB_ERD" => Ok(CurrencyPair::ErdBnb),
            "BTC_ERD" => Ok(CurrencyPair::ErdBtc),
            "PAX_ERD" => Ok(CurrencyPair::ErdPax),
            "USDC_ERD" => Ok(CurrencyPair::ErdUsdc),
            "USDT_ERD" => Ok(CurrencyPair::ErdUsdt),
            "BNB_ETC" => Ok(CurrencyPair::EtcBnb),
            "BTC_ETC" => Ok(CurrencyPair::EtcBtc),
            "BUSD_ETC" => Ok(CurrencyPair::EtcBusd),
            "ETH_ETC" => Ok(CurrencyPair::EtcEth),
            "PAX_ETC" => Ok(CurrencyPair::EtcPax),
            "TUSD_ETC" => Ok(CurrencyPair::EtcTusd),
            "USDC_ETC" => Ok(CurrencyPair::EtcUsdc),
            "USDT_ETC" => Ok(CurrencyPair::EtcUsdt),
            "BTC_ETH" => Ok(CurrencyPair::EthBtc),
            "BUSD_ETH" => Ok(CurrencyPair::EthBusd),
            "PAX_ETH" => Ok(CurrencyPair::EthPax),
            "RUB_ETH" => Ok(CurrencyPair::EthRub),
            "TRY_ETH" => Ok(CurrencyPair::EthTry),
            "TUSD_ETH" => Ok(CurrencyPair::EthTusd),
            "USDC_ETH" => Ok(CurrencyPair::EthUsdc),
            "USDT_ETH" => Ok(CurrencyPair::EthUsdt),
            "BTC_EVX" => Ok(CurrencyPair::EvxBtc),
            "ETH_EVX" => Ok(CurrencyPair::EvxEth),
            "BNB_FET" => Ok(CurrencyPair::FetBnb),
            "BTC_FET" => Ok(CurrencyPair::FetBtc),
            "USDT_FET" => Ok(CurrencyPair::FetUsdt),
            "BNB_FTM" => Ok(CurrencyPair::FtmBnb),
            "BTC_FTM" => Ok(CurrencyPair::FtmBtc),
            "PAX_FTM" => Ok(CurrencyPair::FtmPax),
            "TUSD_FTM" => Ok(CurrencyPair::FtmTusd),
            "USDC_FTM" => Ok(CurrencyPair::FtmUsdc),
            "USDT_FTM" => Ok(CurrencyPair::FtmUsdt),
            "BNB_FTT" => Ok(CurrencyPair::FttBnb),
            "BTC_FTT" => Ok(CurrencyPair::FttBtc),
            "USDT_FTT" => Ok(CurrencyPair::FttUsdt),
            "BTC_FUEL" => Ok(CurrencyPair::FuelBtc),
            "ETH_FUEL" => Ok(CurrencyPair::FuelEth),
            "BTC_FUN" => Ok(CurrencyPair::FunBtc),
            "ETH_FUN" => Ok(CurrencyPair::FunEth),
            "USDT_FUN" => Ok(CurrencyPair::FunUsdt),
            "BTC_GAS" => Ok(CurrencyPair::GasBtc),
            "BNB_GNT" => Ok(CurrencyPair::GntBnb),
            "BTC_GNT" => Ok(CurrencyPair::GntBtc),
            "ETH_GNT" => Ok(CurrencyPair::GntEth),
            "BNB_GO" => Ok(CurrencyPair::GoBnb),
            "BTC_GO" => Ok(CurrencyPair::GoBtc),
            "BTC_GRS" => Ok(CurrencyPair::GrsBtc),
            "ETH_GRS" => Ok(CurrencyPair::GrsEth),
            "BNB_GTO" => Ok(CurrencyPair::GtoBnb),
            "BTC_GTO" => Ok(CurrencyPair::GtoBtc),
            "ETH_GTO" => Ok(CurrencyPair::GtoEth),
            "PAX_GTO" => Ok(CurrencyPair::GtoPax),
            "TUSD_GTO" => Ok(CurrencyPair::GtoTusd),
            "USDC_GTO" => Ok(CurrencyPair::GtoUsdc),
            "USDT_GTO" => Ok(CurrencyPair::GtoUsdt),
            "BTC_GVT" => Ok(CurrencyPair::GvtBtc),
            "ETH_GVT" => Ok(CurrencyPair::GvtEth),
            "BTC_GXS" => Ok(CurrencyPair::GxsBtc),
            "ETH_GXS" => Ok(CurrencyPair::GxsEth),
            "BNB_HBAR" => Ok(CurrencyPair::HbarBnb),
            "BTC_HBAR" => Ok(CurrencyPair::HbarBtc),
            "USDT_HBAR" => Ok(CurrencyPair::HbarUsdt),
            "BTC_HC" => Ok(CurrencyPair::HcBtc),
            "ETH_HC" => Ok(CurrencyPair::HcEth),
            "USDT_HC" => Ok(CurrencyPair::HcUsdt),
            "BNB_HOT" => Ok(CurrencyPair::HotBnb),
            "BTC_HOT" => Ok(CurrencyPair::HotBtc),
            "ETH_HOT" => Ok(CurrencyPair::HotEth),
            "USDT_HOT" => Ok(CurrencyPair::HotUsdt),
            "BTC_HSR" => Ok(CurrencyPair::HsrBtc),
            "ETH_HSR" => Ok(CurrencyPair::HsrEth),
            "BTC_ICN" => Ok(CurrencyPair::IcnBtc),
            "ETH_ICN" => Ok(CurrencyPair::IcnEth),
            "BNB_ICX" => Ok(CurrencyPair::IcxBnb),
            "BTC_ICX" => Ok(CurrencyPair::IcxBtc),
            "ETH_ICX" => Ok(CurrencyPair::IcxEth),
            "USDT_ICX" => Ok(CurrencyPair::IcxUsdt),
            "BTC_INS" => Ok(CurrencyPair::InsBtc),
            "ETH_INS" => Ok(CurrencyPair::InsEth),
            "BNB_IOST" => Ok(CurrencyPair::IostBnb),
            "BTC_IOST" => Ok(CurrencyPair::IostBtc),
            "ETH_IOST" => Ok(CurrencyPair::IostEth),
            "USDT_IOST" => Ok(CurrencyPair::IostUsdt),
            "BNB_IOTA" => Ok(CurrencyPair::IotaBnb),
            "BTC_IOTA" => Ok(CurrencyPair::IotaBtc),
            "ETH_IOTA" => Ok(CurrencyPair::IotaEth),
            "USDT_IOTA" => Ok(CurrencyPair::IotaUsdt),
            "BTC_IOTX" => Ok(CurrencyPair::IotxBtc),
            "ETH_IOTX" => Ok(CurrencyPair::IotxEth),
            "USDT_IOTX" => Ok(CurrencyPair::IotxUsdt),
            "BNB_KAVA" => Ok(CurrencyPair::KavaBnb),
            "BTC_KAVA" => Ok(CurrencyPair::KavaBtc),
            "USDT_KAVA" => Ok(CurrencyPair::KavaUsdt),
            "BTC_KEY" => Ok(CurrencyPair::KeyBtc),
            "ETH_KEY" => Ok(CurrencyPair::KeyEth),
            "USDT_KEY" => Ok(CurrencyPair::KeyUsdt),
            "BTC_KMD" => Ok(CurrencyPair::KmdBtc),
            "ETH_KMD" => Ok(CurrencyPair::KmdEth),
            "BTC_KNC" => Ok(CurrencyPair::KncBtc),
            "ETH_KNC" => Ok(CurrencyPair::KncEth),
            "BTC_LEND" => Ok(CurrencyPair::LendBtc),
            "ETH_LEND" => Ok(CurrencyPair::LendEth),
            "BTC_LINK" => Ok(CurrencyPair::LinkBtc),
            "BUSD_LINK" => Ok(CurrencyPair::LinkBusd),
            "ETH_LINK" => Ok(CurrencyPair::LinkEth),
            "PAX_LINK" => Ok(CurrencyPair::LinkPax),
            "TUSD_LINK" => Ok(CurrencyPair::LinkTusd),
            "USDC_LINK" => Ok(CurrencyPair::LinkUsdc),
            "USDT_LINK" => Ok(CurrencyPair::LinkUsdt),
            "BNB_LOOM" => Ok(CurrencyPair::LoomBnb),
            "BTC_LOOM" => Ok(CurrencyPair::LoomBtc),
            "ETH_LOOM" => Ok(CurrencyPair::LoomEth),
            "BTC_LRC" => Ok(CurrencyPair::LrcBtc),
            "ETH_LRC" => Ok(CurrencyPair::LrcEth),
            "BNB_LSK" => Ok(CurrencyPair::LskBnb),
            "BTC_LSK" => Ok(CurrencyPair::LskBtc),
            "ETH_LSK" => Ok(CurrencyPair::LskEth),
            "BNB_LTC" => Ok(CurrencyPair::LtcBnb),
            "BTC_LTC" => Ok(CurrencyPair::LtcBtc),
            "BUSD_LTC" => Ok(CurrencyPair::LtcBusd),
            "ETH_LTC" => Ok(CurrencyPair::LtcEth),
            "PAX_LTC" => Ok(CurrencyPair::LtcPax),
            "TUSD_LTC" => Ok(CurrencyPair::LtcTusd),
            "USDC_LTC" => Ok(CurrencyPair::LtcUsdc),
            "USDT_LTC" => Ok(CurrencyPair::LtcUsdt),
            "BTC_LUN" => Ok(CurrencyPair::LunBtc),
            "ETH_LUN" => Ok(CurrencyPair::LunEth),
            "BTC_MANA" => Ok(CurrencyPair::ManaBtc),
            "ETH_MANA" => Ok(CurrencyPair::ManaEth),
            "BNB_MATIC" => Ok(CurrencyPair::MaticBnb),
            "BTC_MATIC" => Ok(CurrencyPair::MaticBtc),
            "USDT_MATIC" => Ok(CurrencyPair::MaticUsdt),
            "BNB_MCO" => Ok(CurrencyPair::McoBnb),
            "BTC_MCO" => Ok(CurrencyPair::McoBtc),
            "ETH_MCO" => Ok(CurrencyPair::McoEth),
            "USDT_MCO" => Ok(CurrencyPair::McoUsdt),
            "BTC_MDA" => Ok(CurrencyPair::MdaBtc),
            "ETH_MDA" => Ok(CurrencyPair::MdaEth),
            "BNB_MFT" => Ok(CurrencyPair::MftBnb),
            "BTC_MFT" => Ok(CurrencyPair::MftBtc),
            "ETH_MFT" => Ok(CurrencyPair::MftEth),
            "USDT_MFT" => Ok(CurrencyPair::MftUsdt),
            "BNB_MITH" => Ok(CurrencyPair::MithBnb),
            "BTC_MITH" => Ok(CurrencyPair::MithBtc),
            "USDT_MITH" => Ok(CurrencyPair::MithUsdt),
            "BTC_MOD" => Ok(CurrencyPair::ModBtc),
            "ETH_MOD" => Ok(CurrencyPair::ModEth),
            "BTC_MTH" => Ok(CurrencyPair::MthBtc),
            "ETH_MTH" => Ok(CurrencyPair::MthEth),
            "BTC_MTL" => Ok(CurrencyPair::MtlBtc),
            "ETH_MTL" => Ok(CurrencyPair::MtlEth),
            "USDT_MTL" => Ok(CurrencyPair::MtlUsdt),
            "BNB_NANO" => Ok(CurrencyPair::NanoBnb),
            "BTC_NANO" => Ok(CurrencyPair::NanoBtc),
            "ETH_NANO" => Ok(CurrencyPair::NanoEth),
            "USDT_NANO" => Ok(CurrencyPair::NanoUsdt),
            "BNB_NAS" => Ok(CurrencyPair::NasBnb),
            "BTC_NAS" => Ok(CurrencyPair::NasBtc),
            "ETH_NAS" => Ok(CurrencyPair::NasEth),
            "BNB_NAV" => Ok(CurrencyPair::NavBnb),
            "BTC_NAV" => Ok(CurrencyPair::NavBtc),
            "ETH_NAV" => Ok(CurrencyPair::NavEth),
            "BNB_NCASH" => Ok(CurrencyPair::NcashBnb),
            "BTC_NCASH" => Ok(CurrencyPair::NcashBtc),
            "ETH_NCASH" => Ok(CurrencyPair::NcashEth),
            "BNB_NEBL" => Ok(CurrencyPair::NeblBnb),
            "BTC_NEBL" => Ok(CurrencyPair::NeblBtc),
            "ETH_NEBL" => Ok(CurrencyPair::NeblEth),
            "BNB_NEO" => Ok(CurrencyPair::NeoBnb),
            "BTC_NEO" => Ok(CurrencyPair::NeoBtc),
            "ETH_NEO" => Ok(CurrencyPair::NeoEth),
            "PAX_NEO" => Ok(CurrencyPair::NeoPax),
            "TUSD_NEO" => Ok(CurrencyPair::NeoTusd),
            "USDC_NEO" => Ok(CurrencyPair::NeoUsdc),
            "USDT_NEO" => Ok(CurrencyPair::NeoUsdt),
            "BNB_NKN" => Ok(CurrencyPair::NknBnb),
            "BTC_NKN" => Ok(CurrencyPair::NknBtc),
            "USDT_NKN" => Ok(CurrencyPair::NknUsdt),
            "BTC_NPXS" => Ok(CurrencyPair::NpxsBtc),
            "ETH_NPXS" => Ok(CurrencyPair::NpxsEth),
            "USDC_NPXS" => Ok(CurrencyPair::NpxsUsdc),
            "USDT_NPXS" => Ok(CurrencyPair::NpxsUsdt),
            "BNB_NULS" => Ok(CurrencyPair::NulsBnb),
            "BTC_NULS" => Ok(CurrencyPair::NulsBtc),
            "ETH_NULS" => Ok(CurrencyPair::NulsEth),
            "USDT_NULS" => Ok(CurrencyPair::NulsUsdt),
            "BNB_NXS" => Ok(CurrencyPair::NxsBnb),
            "BTC_NXS" => Ok(CurrencyPair::NxsBtc),
            "ETH_NXS" => Ok(CurrencyPair::NxsEth),
            "BTC_OAX" => Ok(CurrencyPair::OaxBtc),
            "ETH_OAX" => Ok(CurrencyPair::OaxEth),
            "BNB_OMG" => Ok(CurrencyPair::OmgBnb),
            "BTC_OMG" => Ok(CurrencyPair::OmgBtc),
            "ETH_OMG" => Ok(CurrencyPair::OmgEth),
            "USDT_OMG" => Ok(CurrencyPair::OmgUsdt),
            "BNB_ONE" => Ok(CurrencyPair::OneBnb),
            "BTC_ONE" => Ok(CurrencyPair::OneBtc),
            "PAX_ONE" => Ok(CurrencyPair::OnePax),
            "TUSD_ONE" => Ok(CurrencyPair::OneTusd),
            "USDC_ONE" => Ok(CurrencyPair::OneUsdc),
            "USDT_ONE" => Ok(CurrencyPair::OneUsdt),
            "BNB_ONG" => Ok(CurrencyPair::OngBnb),
            "BTC_ONG" => Ok(CurrencyPair::OngBtc),
            "USDT_ONG" => Ok(CurrencyPair::OngUsdt),
            "BNB_ONT" => Ok(CurrencyPair::OntBnb),
            "BTC_ONT" => Ok(CurrencyPair::OntBtc),
            "ETH_ONT" => Ok(CurrencyPair::OntEth),
            "PAX_ONT" => Ok(CurrencyPair::OntPax),
            "USDC_ONT" => Ok(CurrencyPair::OntUsdc),
            "USDT_ONT" => Ok(CurrencyPair::OntUsdt),
            "BNB_OST" => Ok(CurrencyPair::OstBnb),
            "BTC_OST" => Ok(CurrencyPair::OstBtc),
            "ETH_OST" => Ok(CurrencyPair::OstEth),
            "BNB_PAX" => Ok(CurrencyPair::PaxBnb),
            "BTC_PAX" => Ok(CurrencyPair::PaxBtc),
            "ETH_PAX" => Ok(CurrencyPair::PaxEth),
            "TUSD_PAX" => Ok(CurrencyPair::PaxTusd),
            "USDT_PAX" => Ok(CurrencyPair::PaxUsdt),
            "BNB_PERL" => Ok(CurrencyPair::PerlBnb),
            "BTC_PERL" => Ok(CurrencyPair::PerlBtc),
            "USDC_PERL" => Ok(CurrencyPair::PerlUsdc),
            "USDT_PERL" => Ok(CurrencyPair::PerlUsdt),
            "BNB_PHB" => Ok(CurrencyPair::PhbBnb),
            "BTC_PHB" => Ok(CurrencyPair::PhbBtc),
            "PAX_PHB" => Ok(CurrencyPair::PhbPax),
            "TUSD_PHB" => Ok(CurrencyPair::PhbTusd),
            "USDC_PHB" => Ok(CurrencyPair::PhbUsdc),
            "BNB_PHX" => Ok(CurrencyPair::PhxBnb),
            "BTC_PHX" => Ok(CurrencyPair::PhxBtc),
            "ETH_PHX" => Ok(CurrencyPair::PhxEth),
            "BNB_PIVX" => Ok(CurrencyPair::PivxBnb),
            "BTC_PIVX" => Ok(CurrencyPair::PivxBtc),
            "ETH_PIVX" => Ok(CurrencyPair::PivxEth),
            "BNB_POA" => Ok(CurrencyPair::PoaBnb),
            "BTC_POA" => Ok(CurrencyPair::PoaBtc),
            "ETH_POA" => Ok(CurrencyPair::PoaEth),
            "BTC_POE" => Ok(CurrencyPair::PoeBtc),
            "ETH_POE" => Ok(CurrencyPair::PoeEth),
            "BNB_POLY" => Ok(CurrencyPair::PolyBnb),
            "BTC_POLY" => Ok(CurrencyPair::PolyBtc),
            "BNB_POWR" => Ok(CurrencyPair::PowrBnb),
            "BTC_POWR" => Ok(CurrencyPair::PowrBtc),
            "ETH_POWR" => Ok(CurrencyPair::PowrEth),
            "BTC_PPT" => Ok(CurrencyPair::PptBtc),
            "ETH_PPT" => Ok(CurrencyPair::PptEth),
            "BTC_QKC" => Ok(CurrencyPair::QkcBtc),
            "ETH_QKC" => Ok(CurrencyPair::QkcEth),
            "BNB_QLC" => Ok(CurrencyPair::QlcBnb),
            "BTC_QLC" => Ok(CurrencyPair::QlcBtc),
            "ETH_QLC" => Ok(CurrencyPair::QlcEth),
            "BNB_QSP" => Ok(CurrencyPair::QspBnb),
            "BTC_QSP" => Ok(CurrencyPair::QspBtc),
            "ETH_QSP" => Ok(CurrencyPair::QspEth),
            "BNB_QTUM" => Ok(CurrencyPair::QtumBnb),
            "BTC_QTUM" => Ok(CurrencyPair::QtumBtc),
            "BUSD_QTUM" => Ok(CurrencyPair::QtumBusd),
            "ETH_QTUM" => Ok(CurrencyPair::QtumEth),
            "USDT_QTUM" => Ok(CurrencyPair::QtumUsdt),
            "BNB_RCN" => Ok(CurrencyPair::RcnBnb),
            "BTC_RCN" => Ok(CurrencyPair::RcnBtc),
            "ETH_RCN" => Ok(CurrencyPair::RcnEth),
            "BNB_RDN" => Ok(CurrencyPair::RdnBnb),
            "BTC_RDN" => Ok(CurrencyPair::RdnBtc),
            "ETH_RDN" => Ok(CurrencyPair::RdnEth),
            "BNB_REN" => Ok(CurrencyPair::RenBnb),
            "BTC_REN" => Ok(CurrencyPair::RenBtc),
            "USDT_REN" => Ok(CurrencyPair::RenUsdt),
            "BNB_REP" => Ok(CurrencyPair::RepBnb),
            "BTC_REP" => Ok(CurrencyPair::RepBtc),
            "ETH_REP" => Ok(CurrencyPair::RepEth),
            "BTC_REQ" => Ok(CurrencyPair::ReqBtc),
            "ETH_REQ" => Ok(CurrencyPair::ReqEth),
            "BNB_RLC" => Ok(CurrencyPair::RlcBnb),
            "BTC_RLC" => Ok(CurrencyPair::RlcBtc),
            "ETH_RLC" => Ok(CurrencyPair::RlcEth),
            "USDT_RLC" => Ok(CurrencyPair::RlcUsdt),
            "BNB_RPX" => Ok(CurrencyPair::RpxBnb),
            "BTC_RPX" => Ok(CurrencyPair::RpxBtc),
            "ETH_RPX" => Ok(CurrencyPair::RpxEth),
            "BNB_RVN" => Ok(CurrencyPair::RvnBnb),
            "BTC_RVN" => Ok(CurrencyPair::RvnBtc),
            "USDT_RVN" => Ok(CurrencyPair::RvnUsdt),
            "BTC_SALT" => Ok(CurrencyPair::SaltBtc),
            "ETH_SALT" => Ok(CurrencyPair::SaltEth),
            "BNB_SC" => Ok(CurrencyPair::ScBnb),
            "BTC_SC" => Ok(CurrencyPair::ScBtc),
            "ETH_SC" => Ok(CurrencyPair::ScEth),
            "BNB_SKY" => Ok(CurrencyPair::SkyBnb),
            "BTC_SKY" => Ok(CurrencyPair::SkyBtc),
            "ETH_SKY" => Ok(CurrencyPair::SkyEth),
            "BTC_SNGLS" => Ok(CurrencyPair::SnglsBtc),
            "ETH_SNGLS" => Ok(CurrencyPair::SnglsEth),
            "BTC_SNM" => Ok(CurrencyPair::SnmBtc),
            "ETH_SNM" => Ok(CurrencyPair::SnmEth),
            "BTC_SNT" => Ok(CurrencyPair::SntBtc),
            "ETH_SNT" => Ok(CurrencyPair::SntEth),
            "BNB_STEEM" => Ok(CurrencyPair::SteemBnb),
            "BTC_STEEM" => Ok(CurrencyPair::SteemBtc),
            "ETH_STEEM" => Ok(CurrencyPair::SteemEth),
            "BTC_STORJ" => Ok(CurrencyPair::StorjBtc),
            "ETH_STORJ" => Ok(CurrencyPair::StorjEth),
            "BNB_STORM" => Ok(CurrencyPair::StormBnb),
            "BTC_STORM" => Ok(CurrencyPair::StormBtc),
            "ETH_STORM" => Ok(CurrencyPair::StormEth),
            "USDT_STORM" => Ok(CurrencyPair::StormUsdt),
            "BTC_STRAT" => Ok(CurrencyPair::StratBtc),
            "ETH_STRAT" => Ok(CurrencyPair::StratEth),
            "BNB_STX" => Ok(CurrencyPair::StxBnb),
            "BTC_STX" => Ok(CurrencyPair::StxBtc),
            "USDT_STX" => Ok(CurrencyPair::StxUsdt),
            "BTC_SUB" => Ok(CurrencyPair::SubBtc),
            "ETH_SUB" => Ok(CurrencyPair::SubEth),
            "BNB_SYS" => Ok(CurrencyPair::SysBnb),
            "BTC_SYS" => Ok(CurrencyPair::SysBtc),
            "ETH_SYS" => Ok(CurrencyPair::SysEth),
            "BNB_TFUEL" => Ok(CurrencyPair::TfuelBnb),
            "BTC_TFUEL" => Ok(CurrencyPair::TfuelBtc),
            "PAX_TFUEL" => Ok(CurrencyPair::TfuelPax),
            "TUSD_TFUEL" => Ok(CurrencyPair::TfuelTusd),
            "USDC_TFUEL" => Ok(CurrencyPair::TfuelUsdc),
            "USDT_TFUEL" => Ok(CurrencyPair::TfuelUsdt),
            "BNB_THETA" => Ok(CurrencyPair::ThetaBnb),
            "BTC_THETA" => Ok(CurrencyPair::ThetaBtc),
            "ETH_THETA" => Ok(CurrencyPair::ThetaEth),
            "USDT_THETA" => Ok(CurrencyPair::ThetaUsdt),
            "BTC_TNB" => Ok(CurrencyPair::TnbBtc),
            "ETH_TNB" => Ok(CurrencyPair::TnbEth),
            "BTC_TNT" => Ok(CurrencyPair::TntBtc),
            "ETH_TNT" => Ok(CurrencyPair::TntEth),
            "BNB_TOMO" => Ok(CurrencyPair::TomoBnb),
            "BTC_TOMO" => Ok(CurrencyPair::TomoBtc),
            "USDC_TOMO" => Ok(CurrencyPair::TomoUsdc),
            "USDT_TOMO" => Ok(CurrencyPair::TomoUsdt),
            "BNB_TRIG" => Ok(CurrencyPair::TrigBnb),
            "BTC_TRIG" => Ok(CurrencyPair::TrigBtc),
            "ETH_TRIG" => Ok(CurrencyPair::TrigEth),
            "BNB_TROY" => Ok(CurrencyPair::TroyBnb),
            "BTC_TROY" => Ok(CurrencyPair::TroyBtc),
            "USDT_TROY" => Ok(CurrencyPair::TroyUsdt),
            "BNB_TRX" => Ok(CurrencyPair::TrxBnb),
            "BTC_TRX" => Ok(CurrencyPair::TrxBtc),
            "BUSD_TRX" => Ok(CurrencyPair::TrxBusd),
            "ETH_TRX" => Ok(CurrencyPair::TrxEth),
            "PAX_TRX" => Ok(CurrencyPair::TrxPax),
            "TUSD_TRX" => Ok(CurrencyPair::TrxTusd),
            "USDC_TRX" => Ok(CurrencyPair::TrxUsdc),
            "USDT_TRX" => Ok(CurrencyPair::TrxUsdt),
            "XRP_TRX" => Ok(CurrencyPair::TrxXrp),
            "TUSD_TUSDB" => Ok(CurrencyPair::TusdbTusd),
            "BNB_TUSD" => Ok(CurrencyPair::TusdBnb),
            "BTC_TUSD" => Ok(CurrencyPair::TusdBtc),
            "ETH_TUSD" => Ok(CurrencyPair::TusdEth),
            "USDT_TUSD" => Ok(CurrencyPair::TusdUsdt),
            "BNB_USDC" => Ok(CurrencyPair::UsdcBnb),
            "DASH_USDC" => Ok(CurrencyPair::UsdcDash),
            "GRIN_USDC" => Ok(CurrencyPair::UsdcGrin),
            "PAX_USDC" => Ok(CurrencyPair::UsdcPax),
            "STR_USDC" => Ok(CurrencyPair::UsdcStr),
            "TUSD_USDC" => Ok(CurrencyPair::UsdcTusd),
            "USDT_USDC" => Ok(CurrencyPair::UsdcUsdt),
            "XMR_USDC" => Ok(CurrencyPair::UsdcXmr),
            "USDS_USDSB" => Ok(CurrencyPair::UsdsbUsds),
            "USDT_USDSB" => Ok(CurrencyPair::UsdsbUsdt),
            "PAX_USDS" => Ok(CurrencyPair::UsdsPax),
            "TUSD_USDS" => Ok(CurrencyPair::UsdsTusd),
            "USDC_USDS" => Ok(CurrencyPair::UsdsUsdc),
            "USDT_USDS" => Ok(CurrencyPair::UsdsUsdt),
            "DGB_USDT" => Ok(CurrencyPair::UsdtDgb),
            "GNT_USDT" => Ok(CurrencyPair::UsdtGnt),
            "GRIN_USDT" => Ok(CurrencyPair::UsdtGrin),
            "LSK_USDT" => Ok(CurrencyPair::UsdtLsk),
            "MANA_USDT" => Ok(CurrencyPair::UsdtMana),
            "NXT_USDT" => Ok(CurrencyPair::UsdtNxt),
            "REP_USDT" => Ok(CurrencyPair::UsdtRep),
            "RUB_USDT" => Ok(CurrencyPair::UsdtRub),
            "SC_USDT" => Ok(CurrencyPair::UsdtSc),
            "STR_USDT" => Ok(CurrencyPair::UsdtStr),
            "TRY_USDT" => Ok(CurrencyPair::UsdtTry),
            "BNB_VEN" => Ok(CurrencyPair::VenBnb),
            "BTC_VEN" => Ok(CurrencyPair::VenBtc),
            "ETH_VEN" => Ok(CurrencyPair::VenEth),
            "USDT_VEN" => Ok(CurrencyPair::VenUsdt),
            "BNB_VET" => Ok(CurrencyPair::VetBnb),
            "BTC_VET" => Ok(CurrencyPair::VetBtc),
            "BUSD_VET" => Ok(CurrencyPair::VetBusd),
            "ETH_VET" => Ok(CurrencyPair::VetEth),
            "USDT_VET" => Ok(CurrencyPair::VetUsdt),
            "BNB_VIA" => Ok(CurrencyPair::ViaBnb),
            "BTC_VIA" => Ok(CurrencyPair::ViaBtc),
            "ETH_VIA" => Ok(CurrencyPair::ViaEth),
            "BTC_VIBE" => Ok(CurrencyPair::VibeBtc),
            "ETH_VIBE" => Ok(CurrencyPair::VibeEth),
            "BTC_VIB" => Ok(CurrencyPair::VibBtc),
            "ETH_VIB" => Ok(CurrencyPair::VibEth),
            "BNB_VITE" => Ok(CurrencyPair::ViteBnb),
            "BTC_VITE" => Ok(CurrencyPair::ViteBtc),
            "USDT_VITE" => Ok(CurrencyPair::ViteUsdt),
            "BNB_WABI" => Ok(CurrencyPair::WabiBnb),
            "BTC_WABI" => Ok(CurrencyPair::WabiBtc),
            "ETH_WABI" => Ok(CurrencyPair::WabiEth),
            "BNB_WAN" => Ok(CurrencyPair::WanBnb),
            "BTC_WAN" => Ok(CurrencyPair::WanBtc),
            "ETH_WAN" => Ok(CurrencyPair::WanEth),
            "USDT_WAN" => Ok(CurrencyPair::WanUsdt),
            "BNB_WAVES" => Ok(CurrencyPair::WavesBnb),
            "BTC_WAVES" => Ok(CurrencyPair::WavesBtc),
            "ETH_WAVES" => Ok(CurrencyPair::WavesEth),
            "PAX_WAVES" => Ok(CurrencyPair::WavesPax),
            "TUSD_WAVES" => Ok(CurrencyPair::WavesTusd),
            "USDC_WAVES" => Ok(CurrencyPair::WavesUsdc),
            "USDT_WAVES" => Ok(CurrencyPair::WavesUsdt),
            "BTC_WINGS" => Ok(CurrencyPair::WingsBtc),
            "ETH_WINGS" => Ok(CurrencyPair::WingsEth),
            "BNB_WIN" => Ok(CurrencyPair::WinBnb),
            "BTC_WIN" => Ok(CurrencyPair::WinBtc),
            "TRX_WIN" => Ok(CurrencyPair::WinTrx),
            "USDC_WIN" => Ok(CurrencyPair::WinUsdc),
            "USDT_WIN" => Ok(CurrencyPair::WinUsdt),
            "BTC_WPR" => Ok(CurrencyPair::WprBtc),
            "ETH_WPR" => Ok(CurrencyPair::WprEth),
            "BNB_WTC" => Ok(CurrencyPair::WtcBnb),
            "BTC_WTC" => Ok(CurrencyPair::WtcBtc),
            "ETH_WTC" => Ok(CurrencyPair::WtcEth),
            "BNB_XEM" => Ok(CurrencyPair::XemBnb),
            "BTC_XEM" => Ok(CurrencyPair::XemBtc),
            "ETH_XEM" => Ok(CurrencyPair::XemEth),
            "BNB_XLM" => Ok(CurrencyPair::XlmBnb),
            "BTC_XLM" => Ok(CurrencyPair::XlmBtc),
            "BUSD_XLM" => Ok(CurrencyPair::XlmBusd),
            "ETH_XLM" => Ok(CurrencyPair::XlmEth),
            "PAX_XLM" => Ok(CurrencyPair::XlmPax),
            "TUSD_XLM" => Ok(CurrencyPair::XlmTusd),
            "USDC_XLM" => Ok(CurrencyPair::XlmUsdc),
            "USDT_XLM" => Ok(CurrencyPair::XlmUsdt),
            "BNB_XMR" => Ok(CurrencyPair::XmrBnb),
            "BTC_XMR" => Ok(CurrencyPair::XmrBtc),
            "ETH_XMR" => Ok(CurrencyPair::XmrEth),
            "USDT_XMR" => Ok(CurrencyPair::XmrUsdt),
            "BNB_XRP" => Ok(CurrencyPair::XrpBnb),
            "BTC_XRP" => Ok(CurrencyPair::XrpBtc),
            "BUSD_XRP" => Ok(CurrencyPair::XrpBusd),
            "ETH_XRP" => Ok(CurrencyPair::XrpEth),
            "PAX_XRP" => Ok(CurrencyPair::XrpPax),
            "RUB_XRP" => Ok(CurrencyPair::XrpRub),
            "TRY_XRP" => Ok(CurrencyPair::XrpTry),
            "TUSD_XRP" => Ok(CurrencyPair::XrpTusd),
            "USDC_XRP" => Ok(CurrencyPair::XrpUsdc),
            "USDT_XRP" => Ok(CurrencyPair::XrpUsdt),
            "BNB_XTZ" => Ok(CurrencyPair::XtzBnb),
            "BTC_XTZ" => Ok(CurrencyPair::XtzBtc),
            "USDT_XTZ" => Ok(CurrencyPair::XtzUsdt),
            "BTC_XVG" => Ok(CurrencyPair::XvgBtc),
            "ETH_XVG" => Ok(CurrencyPair::XvgEth),
            "BNB_XZC" => Ok(CurrencyPair::XzcBnb),
            "BTC_XZC" => Ok(CurrencyPair::XzcBtc),
            "ETH_XZC" => Ok(CurrencyPair::XzcEth),
            "XRP_XZC" => Ok(CurrencyPair::XzcXrp),
            "BNB_YOYO" => Ok(CurrencyPair::YoyoBnb),
            "BTC_YOYO" => Ok(CurrencyPair::YoyoBtc),
            "ETH_YOYO" => Ok(CurrencyPair::YoyoEth),
            "BNB_ZEC" => Ok(CurrencyPair::ZecBnb),
            "BTC_ZEC" => Ok(CurrencyPair::ZecBtc),
            "ETH_ZEC" => Ok(CurrencyPair::ZecEth),
            "PAX_ZEC" => Ok(CurrencyPair::ZecPax),
            "TUSD_ZEC" => Ok(CurrencyPair::ZecTusd),
            "USDC_ZEC" => Ok(CurrencyPair::ZecUsdc),
            "USDT_ZEC" => Ok(CurrencyPair::ZecUsdt),
            "BNB_ZEN" => Ok(CurrencyPair::ZenBnb),
            "BTC_ZEN" => Ok(CurrencyPair::ZenBtc),
            "ETH_ZEN" => Ok(CurrencyPair::ZenEth),
            "BNB_ZIL" => Ok(CurrencyPair::ZilBnb),
            "BTC_ZIL" => Ok(CurrencyPair::ZilBtc),
            "ETH_ZIL" => Ok(CurrencyPair::ZilEth),
            "USDT_ZIL" => Ok(CurrencyPair::ZilUsdt),
            "BNB_ZRX" => Ok(CurrencyPair::ZrxBnb),
            "BTC_ZRX" => Ok(CurrencyPair::ZrxBtc),
            "ETH_ZRX" => Ok(CurrencyPair::ZrxEth),
            "USDT_ZRX" => Ok(CurrencyPair::ZrxUsdt),
            pair => {
                let index = pair
                    .find('_')
                    .ok_or_else(|| Error::InvalidPair(pair.to_owned()))?;
                if index == pair.len() - 1 {
                    return Err(Error::InvalidPair(pair.to_owned()));
                }
                let quote: Currency = pair[..index].into();
                let base: Currency = pair[index + 1..].into();
                Ok(CurrencyPair::Custom(
                    format!("{}_{}", quote, base),
                    quote,
                    base,
                ))
            }
        }
    }

    pub fn join_no_sep(&self) -> String {
        match self {
            CurrencyPair::Custom(_, ref quote, ref base) => format!("{}{}", quote, base),
            &CurrencyPair::AdaBnb => "ADABNB".to_owned(),
            &CurrencyPair::AdaBtc => "ADABTC".to_owned(),
            &CurrencyPair::AdaBusd => "ADABUSD".to_owned(),
            &CurrencyPair::AdaEth => "ADAETH".to_owned(),
            &CurrencyPair::AdaPax => "ADAPAX".to_owned(),
            &CurrencyPair::AdaTusd => "ADATUSD".to_owned(),
            &CurrencyPair::AdaUsdc => "ADAUSDC".to_owned(),
            &CurrencyPair::AdaUsdt => "ADAUSDT".to_owned(),
            &CurrencyPair::AdxBnb => "ADXBNB".to_owned(),
            &CurrencyPair::AdxBtc => "ADXBTC".to_owned(),
            &CurrencyPair::AdxEth => "ADXETH".to_owned(),
            &CurrencyPair::AeBnb => "AEBNB".to_owned(),
            &CurrencyPair::AeBtc => "AEBTC".to_owned(),
            &CurrencyPair::AeEth => "AEETH".to_owned(),
            &CurrencyPair::AgiBnb => "AGIBNB".to_owned(),
            &CurrencyPair::AgiBtc => "AGIBTC".to_owned(),
            &CurrencyPair::AgiEth => "AGIETH".to_owned(),
            &CurrencyPair::AionBnb => "AIONBNB".to_owned(),
            &CurrencyPair::AionBtc => "AIONBTC".to_owned(),
            &CurrencyPair::AionEth => "AIONETH".to_owned(),
            &CurrencyPair::AlgoBnb => "ALGOBNB".to_owned(),
            &CurrencyPair::AlgoBtc => "ALGOBTC".to_owned(),
            &CurrencyPair::AlgoPax => "ALGOPAX".to_owned(),
            &CurrencyPair::AlgoTusd => "ALGOTUSD".to_owned(),
            &CurrencyPair::AlgoUsdc => "ALGOUSDC".to_owned(),
            &CurrencyPair::AlgoUsdt => "ALGOUSDT".to_owned(),
            &CurrencyPair::AmbBnb => "AMBBNB".to_owned(),
            &CurrencyPair::AmbBtc => "AMBBTC".to_owned(),
            &CurrencyPair::AmbEth => "AMBETH".to_owned(),
            &CurrencyPair::AnkrBnb => "ANKRBNB".to_owned(),
            &CurrencyPair::AnkrBtc => "ANKRBTC".to_owned(),
            &CurrencyPair::AnkrPax => "ANKRPAX".to_owned(),
            &CurrencyPair::AnkrTusd => "ANKRTUSD".to_owned(),
            &CurrencyPair::AnkrUsdc => "ANKRUSDC".to_owned(),
            &CurrencyPair::AnkrUsdt => "ANKRUSDT".to_owned(),
            &CurrencyPair::AppcBnb => "APPCBNB".to_owned(),
            &CurrencyPair::AppcBtc => "APPCBTC".to_owned(),
            &CurrencyPair::AppcEth => "APPCETH".to_owned(),
            &CurrencyPair::ArdrBnb => "ARDRBNB".to_owned(),
            &CurrencyPair::ArdrBtc => "ARDRBTC".to_owned(),
            &CurrencyPair::ArdrEth => "ARDRETH".to_owned(),
            &CurrencyPair::ArkBtc => "ARKBTC".to_owned(),
            &CurrencyPair::ArkEth => "ARKETH".to_owned(),
            &CurrencyPair::ArnBtc => "ARNBTC".to_owned(),
            &CurrencyPair::ArnEth => "ARNETH".to_owned(),
            &CurrencyPair::ArpaBnb => "ARPABNB".to_owned(),
            &CurrencyPair::ArpaBtc => "ARPABTC".to_owned(),
            &CurrencyPair::ArpaUsdt => "ARPAUSDT".to_owned(),
            &CurrencyPair::AstBtc => "ASTBTC".to_owned(),
            &CurrencyPair::AstEth => "ASTETH".to_owned(),
            &CurrencyPair::AtomBnb => "ATOMBNB".to_owned(),
            &CurrencyPair::AtomBtc => "ATOMBTC".to_owned(),
            &CurrencyPair::AtomPax => "ATOMPAX".to_owned(),
            &CurrencyPair::AtomTusd => "ATOMTUSD".to_owned(),
            &CurrencyPair::AtomUsdc => "ATOMUSDC".to_owned(),
            &CurrencyPair::AtomUsdt => "ATOMUSDT".to_owned(),
            &CurrencyPair::BandBnb => "BANDBNB".to_owned(),
            &CurrencyPair::BandBtc => "BANDBTC".to_owned(),
            &CurrencyPair::BandUsdt => "BANDUSDT".to_owned(),
            &CurrencyPair::BatBnb => "BATBNB".to_owned(),
            &CurrencyPair::BatBtc => "BATBTC".to_owned(),
            &CurrencyPair::BatEth => "BATETH".to_owned(),
            &CurrencyPair::BatPax => "BATPAX".to_owned(),
            &CurrencyPair::BatTusd => "BATTUSD".to_owned(),
            &CurrencyPair::BatUsdc => "BATUSDC".to_owned(),
            &CurrencyPair::BatUsdt => "BATUSDT".to_owned(),
            &CurrencyPair::BccBnb => "BCCBNB".to_owned(),
            &CurrencyPair::BccBtc => "BCCBTC".to_owned(),
            &CurrencyPair::BccEth => "BCCETH".to_owned(),
            &CurrencyPair::BccUsdt => "BCCUSDT".to_owned(),
            &CurrencyPair::BcdBtc => "BCDBTC".to_owned(),
            &CurrencyPair::BcdEth => "BCDETH".to_owned(),
            &CurrencyPair::BchabcBtc => "BCHABCBTC".to_owned(),
            &CurrencyPair::BchabcBusd => "BCHABCBUSD".to_owned(),
            &CurrencyPair::BchabcPax => "BCHABCPAX".to_owned(),
            &CurrencyPair::BchabcTusd => "BCHABCTUSD".to_owned(),
            &CurrencyPair::BchabcUsdc => "BCHABCUSDC".to_owned(),
            &CurrencyPair::BchabcUsdt => "BCHABCUSDT".to_owned(),
            &CurrencyPair::BchsvBtc => "BCHSVBTC".to_owned(),
            &CurrencyPair::BchsvPax => "BCHSVPAX".to_owned(),
            &CurrencyPair::BchsvTusd => "BCHSVTUSD".to_owned(),
            &CurrencyPair::BchsvUsdc => "BCHSVUSDC".to_owned(),
            &CurrencyPair::BchsvUsdt => "BCHSVUSDT".to_owned(),
            &CurrencyPair::BchBnb => "BCHBNB".to_owned(),
            &CurrencyPair::BchBtc => "BCHBTC".to_owned(),
            &CurrencyPair::BchBusd => "BCHBUSD".to_owned(),
            &CurrencyPair::BchPax => "BCHPAX".to_owned(),
            &CurrencyPair::BchTusd => "BCHTUSD".to_owned(),
            &CurrencyPair::BchUsdc => "BCHUSDC".to_owned(),
            &CurrencyPair::BchUsdt => "BCHUSDT".to_owned(),
            &CurrencyPair::BcnBnb => "BCNBNB".to_owned(),
            &CurrencyPair::BcnBtc => "BCNBTC".to_owned(),
            &CurrencyPair::BcnEth => "BCNETH".to_owned(),
            &CurrencyPair::BcptBnb => "BCPTBNB".to_owned(),
            &CurrencyPair::BcptBtc => "BCPTBTC".to_owned(),
            &CurrencyPair::BcptEth => "BCPTETH".to_owned(),
            &CurrencyPair::BcptPax => "BCPTPAX".to_owned(),
            &CurrencyPair::BcptTusd => "BCPTTUSD".to_owned(),
            &CurrencyPair::BcptUsdc => "BCPTUSDC".to_owned(),
            &CurrencyPair::BeamBnb => "BEAMBNB".to_owned(),
            &CurrencyPair::BeamBtc => "BEAMBTC".to_owned(),
            &CurrencyPair::BeamUsdt => "BEAMUSDT".to_owned(),
            &CurrencyPair::BgbpUsdc => "BGBPUSDC".to_owned(),
            &CurrencyPair::BlzBnb => "BLZBNB".to_owned(),
            &CurrencyPair::BlzBtc => "BLZBTC".to_owned(),
            &CurrencyPair::BlzEth => "BLZETH".to_owned(),
            &CurrencyPair::BnbBtc => "BNBBTC".to_owned(),
            &CurrencyPair::BnbBusd => "BNBBUSD".to_owned(),
            &CurrencyPair::BnbEth => "BNBETH".to_owned(),
            &CurrencyPair::BnbNgn => "BNBNGN".to_owned(),
            &CurrencyPair::BnbPax => "BNBPAX".to_owned(),
            &CurrencyPair::BnbRub => "BNBRUB".to_owned(),
            &CurrencyPair::BnbTry => "BNBTRY".to_owned(),
            &CurrencyPair::BnbTusd => "BNBTUSD".to_owned(),
            &CurrencyPair::BnbUsdc => "BNBUSDC".to_owned(),
            &CurrencyPair::BnbUsds => "BNBUSDS".to_owned(),
            &CurrencyPair::BnbUsdt => "BNBUSDT".to_owned(),
            &CurrencyPair::BntBtc => "BNTBTC".to_owned(),
            &CurrencyPair::BntEth => "BNTETH".to_owned(),
            &CurrencyPair::BqxBtc => "BQXBTC".to_owned(),
            &CurrencyPair::BqxEth => "BQXETH".to_owned(),
            &CurrencyPair::BrdBnb => "BRDBNB".to_owned(),
            &CurrencyPair::BrdBtc => "BRDBTC".to_owned(),
            &CurrencyPair::BrdEth => "BRDETH".to_owned(),
            &CurrencyPair::BtcbBtc => "BTCBBTC".to_owned(),
            &CurrencyPair::BtcBusd => "BTCBUSD".to_owned(),
            &CurrencyPair::BtcDgb => "BTCDGB".to_owned(),
            &CurrencyPair::BtcFct => "BTCFCT".to_owned(),
            &CurrencyPair::BtcFoam => "BTCFOAM".to_owned(),
            &CurrencyPair::BtcGrin => "BTCGRIN".to_owned(),
            &CurrencyPair::BtcLpt => "BTCLPT".to_owned(),
            &CurrencyPair::BtcMaid => "BTCMAID".to_owned(),
            &CurrencyPair::BtcNgn => "BTCNGN".to_owned(),
            &CurrencyPair::BtcNmr => "BTCNMR".to_owned(),
            &CurrencyPair::BtcNxt => "BTCNXT".to_owned(),
            &CurrencyPair::BtcOmni => "BTCOMNI".to_owned(),
            &CurrencyPair::BtcPax => "BTCPAX".to_owned(),
            &CurrencyPair::BtcRub => "BTCRUB".to_owned(),
            &CurrencyPair::BtcStr => "BTCSTR".to_owned(),
            &CurrencyPair::BtcTry => "BTCTRY".to_owned(),
            &CurrencyPair::BtcTusd => "BTCTUSD".to_owned(),
            &CurrencyPair::BtcUsdc => "BTCUSDC".to_owned(),
            &CurrencyPair::BtcUsds => "BTCUSDS".to_owned(),
            &CurrencyPair::BtcUsdt => "BTCUSDT".to_owned(),
            &CurrencyPair::BtcVtc => "BTCVTC".to_owned(),
            &CurrencyPair::BtcXpm => "BTCXPM".to_owned(),
            &CurrencyPair::BtgBtc => "BTGBTC".to_owned(),
            &CurrencyPair::BtgEth => "BTGETH".to_owned(),
            &CurrencyPair::BtsBnb => "BTSBNB".to_owned(),
            &CurrencyPair::BtsBtc => "BTSBTC".to_owned(),
            &CurrencyPair::BtsEth => "BTSETH".to_owned(),
            &CurrencyPair::BttBnb => "BTTBNB".to_owned(),
            &CurrencyPair::BttBtc => "BTTBTC".to_owned(),
            &CurrencyPair::BttPax => "BTTPAX".to_owned(),
            &CurrencyPair::BttTrx => "BTTTRX".to_owned(),
            &CurrencyPair::BttTusd => "BTTTUSD".to_owned(),
            &CurrencyPair::BttUsdc => "BTTUSDC".to_owned(),
            &CurrencyPair::BttUsdt => "BTTUSDT".to_owned(),
            &CurrencyPair::BusdNgn => "BUSDNGN".to_owned(),
            &CurrencyPair::BusdRub => "BUSDRUB".to_owned(),
            &CurrencyPair::BusdTry => "BUSDTRY".to_owned(),
            &CurrencyPair::BusdUsdt => "BUSDUSDT".to_owned(),
            &CurrencyPair::CdtBtc => "CDTBTC".to_owned(),
            &CurrencyPair::CdtEth => "CDTETH".to_owned(),
            &CurrencyPair::CelrBnb => "CELRBNB".to_owned(),
            &CurrencyPair::CelrBtc => "CELRBTC".to_owned(),
            &CurrencyPair::CelrUsdt => "CELRUSDT".to_owned(),
            &CurrencyPair::ChatBtc => "CHATBTC".to_owned(),
            &CurrencyPair::ChatEth => "CHATETH".to_owned(),
            &CurrencyPair::ChzBnb => "CHZBNB".to_owned(),
            &CurrencyPair::ChzBtc => "CHZBTC".to_owned(),
            &CurrencyPair::ChzUsdt => "CHZUSDT".to_owned(),
            &CurrencyPair::CloakBtc => "CLOAKBTC".to_owned(),
            &CurrencyPair::CloakEth => "CLOAKETH".to_owned(),
            &CurrencyPair::CmtBnb => "CMTBNB".to_owned(),
            &CurrencyPair::CmtBtc => "CMTBTC".to_owned(),
            &CurrencyPair::CmtEth => "CMTETH".to_owned(),
            &CurrencyPair::CndBnb => "CNDBNB".to_owned(),
            &CurrencyPair::CndBtc => "CNDBTC".to_owned(),
            &CurrencyPair::CndEth => "CNDETH".to_owned(),
            &CurrencyPair::CocosBnb => "COCOSBNB".to_owned(),
            &CurrencyPair::CocosBtc => "COCOSBTC".to_owned(),
            &CurrencyPair::CocosUsdt => "COCOSUSDT".to_owned(),
            &CurrencyPair::CosBnb => "COSBNB".to_owned(),
            &CurrencyPair::CosBtc => "COSBTC".to_owned(),
            &CurrencyPair::CosUsdt => "COSUSDT".to_owned(),
            &CurrencyPair::CtxcBnb => "CTXCBNB".to_owned(),
            &CurrencyPair::CtxcBtc => "CTXCBTC".to_owned(),
            &CurrencyPair::CtxcUsdt => "CTXCUSDT".to_owned(),
            &CurrencyPair::CvcBnb => "CVCBNB".to_owned(),
            &CurrencyPair::CvcBtc => "CVCBTC".to_owned(),
            &CurrencyPair::CvcEth => "CVCETH".to_owned(),
            &CurrencyPair::CvcUsdt => "CVCUSDT".to_owned(),
            &CurrencyPair::DashBnb => "DASHBNB".to_owned(),
            &CurrencyPair::DashBtc => "DASHBTC".to_owned(),
            &CurrencyPair::DashEth => "DASHETH".to_owned(),
            &CurrencyPair::DashUsdt => "DASHUSDT".to_owned(),
            &CurrencyPair::DataBtc => "DATABTC".to_owned(),
            &CurrencyPair::DataEth => "DATAETH".to_owned(),
            &CurrencyPair::DcrBnb => "DCRBNB".to_owned(),
            &CurrencyPair::DcrBtc => "DCRBTC".to_owned(),
            &CurrencyPair::DentBtc => "DENTBTC".to_owned(),
            &CurrencyPair::DentEth => "DENTETH".to_owned(),
            &CurrencyPair::DentUsdt => "DENTUSDT".to_owned(),
            &CurrencyPair::DgdBtc => "DGDBTC".to_owned(),
            &CurrencyPair::DgdEth => "DGDETH".to_owned(),
            &CurrencyPair::DltBnb => "DLTBNB".to_owned(),
            &CurrencyPair::DltBtc => "DLTBTC".to_owned(),
            &CurrencyPair::DltEth => "DLTETH".to_owned(),
            &CurrencyPair::DntBtc => "DNTBTC".to_owned(),
            &CurrencyPair::DntEth => "DNTETH".to_owned(),
            &CurrencyPair::DockBtc => "DOCKBTC".to_owned(),
            &CurrencyPair::DockEth => "DOCKETH".to_owned(),
            &CurrencyPair::DockUsdt => "DOCKUSDT".to_owned(),
            &CurrencyPair::DogeBnb => "DOGEBNB".to_owned(),
            &CurrencyPair::DogeBtc => "DOGEBTC".to_owned(),
            &CurrencyPair::DogePax => "DOGEPAX".to_owned(),
            &CurrencyPair::DogeUsdc => "DOGEUSDC".to_owned(),
            &CurrencyPair::DogeUsdt => "DOGEUSDT".to_owned(),
            &CurrencyPair::DuskBnb => "DUSKBNB".to_owned(),
            &CurrencyPair::DuskBtc => "DUSKBTC".to_owned(),
            &CurrencyPair::DuskPax => "DUSKPAX".to_owned(),
            &CurrencyPair::DuskUsdc => "DUSKUSDC".to_owned(),
            &CurrencyPair::DuskUsdt => "DUSKUSDT".to_owned(),
            &CurrencyPair::EdoBtc => "EDOBTC".to_owned(),
            &CurrencyPair::EdoEth => "EDOETH".to_owned(),
            &CurrencyPair::ElfBtc => "ELFBTC".to_owned(),
            &CurrencyPair::ElfEth => "ELFETH".to_owned(),
            &CurrencyPair::EngBtc => "ENGBTC".to_owned(),
            &CurrencyPair::EngEth => "ENGETH".to_owned(),
            &CurrencyPair::EnjBnb => "ENJBNB".to_owned(),
            &CurrencyPair::EnjBtc => "ENJBTC".to_owned(),
            &CurrencyPair::EnjEth => "ENJETH".to_owned(),
            &CurrencyPair::EnjUsdt => "ENJUSDT".to_owned(),
            &CurrencyPair::EosBnb => "EOSBNB".to_owned(),
            &CurrencyPair::EosBtc => "EOSBTC".to_owned(),
            &CurrencyPair::EosBusd => "EOSBUSD".to_owned(),
            &CurrencyPair::EosEth => "EOSETH".to_owned(),
            &CurrencyPair::EosPax => "EOSPAX".to_owned(),
            &CurrencyPair::EosTusd => "EOSTUSD".to_owned(),
            &CurrencyPair::EosUsdc => "EOSUSDC".to_owned(),
            &CurrencyPair::EosUsdt => "EOSUSDT".to_owned(),
            &CurrencyPair::ErdBnb => "ERDBNB".to_owned(),
            &CurrencyPair::ErdBtc => "ERDBTC".to_owned(),
            &CurrencyPair::ErdPax => "ERDPAX".to_owned(),
            &CurrencyPair::ErdUsdc => "ERDUSDC".to_owned(),
            &CurrencyPair::ErdUsdt => "ERDUSDT".to_owned(),
            &CurrencyPair::EtcBnb => "ETCBNB".to_owned(),
            &CurrencyPair::EtcBtc => "ETCBTC".to_owned(),
            &CurrencyPair::EtcBusd => "ETCBUSD".to_owned(),
            &CurrencyPair::EtcEth => "ETCETH".to_owned(),
            &CurrencyPair::EtcPax => "ETCPAX".to_owned(),
            &CurrencyPair::EtcTusd => "ETCTUSD".to_owned(),
            &CurrencyPair::EtcUsdc => "ETCUSDC".to_owned(),
            &CurrencyPair::EtcUsdt => "ETCUSDT".to_owned(),
            &CurrencyPair::EthBtc => "ETHBTC".to_owned(),
            &CurrencyPair::EthBusd => "ETHBUSD".to_owned(),
            &CurrencyPair::EthPax => "ETHPAX".to_owned(),
            &CurrencyPair::EthRub => "ETHRUB".to_owned(),
            &CurrencyPair::EthTry => "ETHTRY".to_owned(),
            &CurrencyPair::EthTusd => "ETHTUSD".to_owned(),
            &CurrencyPair::EthUsdc => "ETHUSDC".to_owned(),
            &CurrencyPair::EthUsdt => "ETHUSDT".to_owned(),
            &CurrencyPair::EvxBtc => "EVXBTC".to_owned(),
            &CurrencyPair::EvxEth => "EVXETH".to_owned(),
            &CurrencyPair::FetBnb => "FETBNB".to_owned(),
            &CurrencyPair::FetBtc => "FETBTC".to_owned(),
            &CurrencyPair::FetUsdt => "FETUSDT".to_owned(),
            &CurrencyPair::FtmBnb => "FTMBNB".to_owned(),
            &CurrencyPair::FtmBtc => "FTMBTC".to_owned(),
            &CurrencyPair::FtmPax => "FTMPAX".to_owned(),
            &CurrencyPair::FtmTusd => "FTMTUSD".to_owned(),
            &CurrencyPair::FtmUsdc => "FTMUSDC".to_owned(),
            &CurrencyPair::FtmUsdt => "FTMUSDT".to_owned(),
            &CurrencyPair::FttBnb => "FTTBNB".to_owned(),
            &CurrencyPair::FttBtc => "FTTBTC".to_owned(),
            &CurrencyPair::FttUsdt => "FTTUSDT".to_owned(),
            &CurrencyPair::FuelBtc => "FUELBTC".to_owned(),
            &CurrencyPair::FuelEth => "FUELETH".to_owned(),
            &CurrencyPair::FunBtc => "FUNBTC".to_owned(),
            &CurrencyPair::FunEth => "FUNETH".to_owned(),
            &CurrencyPair::FunUsdt => "FUNUSDT".to_owned(),
            &CurrencyPair::GasBtc => "GASBTC".to_owned(),
            &CurrencyPair::GntBnb => "GNTBNB".to_owned(),
            &CurrencyPair::GntBtc => "GNTBTC".to_owned(),
            &CurrencyPair::GntEth => "GNTETH".to_owned(),
            &CurrencyPair::GoBnb => "GOBNB".to_owned(),
            &CurrencyPair::GoBtc => "GOBTC".to_owned(),
            &CurrencyPair::GrsBtc => "GRSBTC".to_owned(),
            &CurrencyPair::GrsEth => "GRSETH".to_owned(),
            &CurrencyPair::GtoBnb => "GTOBNB".to_owned(),
            &CurrencyPair::GtoBtc => "GTOBTC".to_owned(),
            &CurrencyPair::GtoEth => "GTOETH".to_owned(),
            &CurrencyPair::GtoPax => "GTOPAX".to_owned(),
            &CurrencyPair::GtoTusd => "GTOTUSD".to_owned(),
            &CurrencyPair::GtoUsdc => "GTOUSDC".to_owned(),
            &CurrencyPair::GtoUsdt => "GTOUSDT".to_owned(),
            &CurrencyPair::GvtBtc => "GVTBTC".to_owned(),
            &CurrencyPair::GvtEth => "GVTETH".to_owned(),
            &CurrencyPair::GxsBtc => "GXSBTC".to_owned(),
            &CurrencyPair::GxsEth => "GXSETH".to_owned(),
            &CurrencyPair::HbarBnb => "HBARBNB".to_owned(),
            &CurrencyPair::HbarBtc => "HBARBTC".to_owned(),
            &CurrencyPair::HbarUsdt => "HBARUSDT".to_owned(),
            &CurrencyPair::HcBtc => "HCBTC".to_owned(),
            &CurrencyPair::HcEth => "HCETH".to_owned(),
            &CurrencyPair::HcUsdt => "HCUSDT".to_owned(),
            &CurrencyPair::HotBnb => "HOTBNB".to_owned(),
            &CurrencyPair::HotBtc => "HOTBTC".to_owned(),
            &CurrencyPair::HotEth => "HOTETH".to_owned(),
            &CurrencyPair::HotUsdt => "HOTUSDT".to_owned(),
            &CurrencyPair::HsrBtc => "HSRBTC".to_owned(),
            &CurrencyPair::HsrEth => "HSRETH".to_owned(),
            &CurrencyPair::IcnBtc => "ICNBTC".to_owned(),
            &CurrencyPair::IcnEth => "ICNETH".to_owned(),
            &CurrencyPair::IcxBnb => "ICXBNB".to_owned(),
            &CurrencyPair::IcxBtc => "ICXBTC".to_owned(),
            &CurrencyPair::IcxEth => "ICXETH".to_owned(),
            &CurrencyPair::IcxUsdt => "ICXUSDT".to_owned(),
            &CurrencyPair::InsBtc => "INSBTC".to_owned(),
            &CurrencyPair::InsEth => "INSETH".to_owned(),
            &CurrencyPair::IostBnb => "IOSTBNB".to_owned(),
            &CurrencyPair::IostBtc => "IOSTBTC".to_owned(),
            &CurrencyPair::IostEth => "IOSTETH".to_owned(),
            &CurrencyPair::IostUsdt => "IOSTUSDT".to_owned(),
            &CurrencyPair::IotaBnb => "IOTABNB".to_owned(),
            &CurrencyPair::IotaBtc => "IOTABTC".to_owned(),
            &CurrencyPair::IotaEth => "IOTAETH".to_owned(),
            &CurrencyPair::IotaUsdt => "IOTAUSDT".to_owned(),
            &CurrencyPair::IotxBtc => "IOTXBTC".to_owned(),
            &CurrencyPair::IotxEth => "IOTXETH".to_owned(),
            &CurrencyPair::IotxUsdt => "IOTXUSDT".to_owned(),
            &CurrencyPair::KavaBnb => "KAVABNB".to_owned(),
            &CurrencyPair::KavaBtc => "KAVABTC".to_owned(),
            &CurrencyPair::KavaUsdt => "KAVAUSDT".to_owned(),
            &CurrencyPair::KeyBtc => "KEYBTC".to_owned(),
            &CurrencyPair::KeyEth => "KEYETH".to_owned(),
            &CurrencyPair::KeyUsdt => "KEYUSDT".to_owned(),
            &CurrencyPair::KmdBtc => "KMDBTC".to_owned(),
            &CurrencyPair::KmdEth => "KMDETH".to_owned(),
            &CurrencyPair::KncBtc => "KNCBTC".to_owned(),
            &CurrencyPair::KncEth => "KNCETH".to_owned(),
            &CurrencyPair::LendBtc => "LENDBTC".to_owned(),
            &CurrencyPair::LendEth => "LENDETH".to_owned(),
            &CurrencyPair::LinkBtc => "LINKBTC".to_owned(),
            &CurrencyPair::LinkBusd => "LINKBUSD".to_owned(),
            &CurrencyPair::LinkEth => "LINKETH".to_owned(),
            &CurrencyPair::LinkPax => "LINKPAX".to_owned(),
            &CurrencyPair::LinkTusd => "LINKTUSD".to_owned(),
            &CurrencyPair::LinkUsdc => "LINKUSDC".to_owned(),
            &CurrencyPair::LinkUsdt => "LINKUSDT".to_owned(),
            &CurrencyPair::LoomBnb => "LOOMBNB".to_owned(),
            &CurrencyPair::LoomBtc => "LOOMBTC".to_owned(),
            &CurrencyPair::LoomEth => "LOOMETH".to_owned(),
            &CurrencyPair::LrcBtc => "LRCBTC".to_owned(),
            &CurrencyPair::LrcEth => "LRCETH".to_owned(),
            &CurrencyPair::LskBnb => "LSKBNB".to_owned(),
            &CurrencyPair::LskBtc => "LSKBTC".to_owned(),
            &CurrencyPair::LskEth => "LSKETH".to_owned(),
            &CurrencyPair::LtcBnb => "LTCBNB".to_owned(),
            &CurrencyPair::LtcBtc => "LTCBTC".to_owned(),
            &CurrencyPair::LtcBusd => "LTCBUSD".to_owned(),
            &CurrencyPair::LtcEth => "LTCETH".to_owned(),
            &CurrencyPair::LtcPax => "LTCPAX".to_owned(),
            &CurrencyPair::LtcTusd => "LTCTUSD".to_owned(),
            &CurrencyPair::LtcUsdc => "LTCUSDC".to_owned(),
            &CurrencyPair::LtcUsdt => "LTCUSDT".to_owned(),
            &CurrencyPair::LunBtc => "LUNBTC".to_owned(),
            &CurrencyPair::LunEth => "LUNETH".to_owned(),
            &CurrencyPair::ManaBtc => "MANABTC".to_owned(),
            &CurrencyPair::ManaEth => "MANAETH".to_owned(),
            &CurrencyPair::MaticBnb => "MATICBNB".to_owned(),
            &CurrencyPair::MaticBtc => "MATICBTC".to_owned(),
            &CurrencyPair::MaticUsdt => "MATICUSDT".to_owned(),
            &CurrencyPair::McoBnb => "MCOBNB".to_owned(),
            &CurrencyPair::McoBtc => "MCOBTC".to_owned(),
            &CurrencyPair::McoEth => "MCOETH".to_owned(),
            &CurrencyPair::McoUsdt => "MCOUSDT".to_owned(),
            &CurrencyPair::MdaBtc => "MDABTC".to_owned(),
            &CurrencyPair::MdaEth => "MDAETH".to_owned(),
            &CurrencyPair::MftBnb => "MFTBNB".to_owned(),
            &CurrencyPair::MftBtc => "MFTBTC".to_owned(),
            &CurrencyPair::MftEth => "MFTETH".to_owned(),
            &CurrencyPair::MftUsdt => "MFTUSDT".to_owned(),
            &CurrencyPair::MithBnb => "MITHBNB".to_owned(),
            &CurrencyPair::MithBtc => "MITHBTC".to_owned(),
            &CurrencyPair::MithUsdt => "MITHUSDT".to_owned(),
            &CurrencyPair::ModBtc => "MODBTC".to_owned(),
            &CurrencyPair::ModEth => "MODETH".to_owned(),
            &CurrencyPair::MthBtc => "MTHBTC".to_owned(),
            &CurrencyPair::MthEth => "MTHETH".to_owned(),
            &CurrencyPair::MtlBtc => "MTLBTC".to_owned(),
            &CurrencyPair::MtlEth => "MTLETH".to_owned(),
            &CurrencyPair::MtlUsdt => "MTLUSDT".to_owned(),
            &CurrencyPair::NanoBnb => "NANOBNB".to_owned(),
            &CurrencyPair::NanoBtc => "NANOBTC".to_owned(),
            &CurrencyPair::NanoEth => "NANOETH".to_owned(),
            &CurrencyPair::NanoUsdt => "NANOUSDT".to_owned(),
            &CurrencyPair::NasBnb => "NASBNB".to_owned(),
            &CurrencyPair::NasBtc => "NASBTC".to_owned(),
            &CurrencyPair::NasEth => "NASETH".to_owned(),
            &CurrencyPair::NavBnb => "NAVBNB".to_owned(),
            &CurrencyPair::NavBtc => "NAVBTC".to_owned(),
            &CurrencyPair::NavEth => "NAVETH".to_owned(),
            &CurrencyPair::NcashBnb => "NCASHBNB".to_owned(),
            &CurrencyPair::NcashBtc => "NCASHBTC".to_owned(),
            &CurrencyPair::NcashEth => "NCASHETH".to_owned(),
            &CurrencyPair::NeblBnb => "NEBLBNB".to_owned(),
            &CurrencyPair::NeblBtc => "NEBLBTC".to_owned(),
            &CurrencyPair::NeblEth => "NEBLETH".to_owned(),
            &CurrencyPair::NeoBnb => "NEOBNB".to_owned(),
            &CurrencyPair::NeoBtc => "NEOBTC".to_owned(),
            &CurrencyPair::NeoEth => "NEOETH".to_owned(),
            &CurrencyPair::NeoPax => "NEOPAX".to_owned(),
            &CurrencyPair::NeoTusd => "NEOTUSD".to_owned(),
            &CurrencyPair::NeoUsdc => "NEOUSDC".to_owned(),
            &CurrencyPair::NeoUsdt => "NEOUSDT".to_owned(),
            &CurrencyPair::NknBnb => "NKNBNB".to_owned(),
            &CurrencyPair::NknBtc => "NKNBTC".to_owned(),
            &CurrencyPair::NknUsdt => "NKNUSDT".to_owned(),
            &CurrencyPair::NpxsBtc => "NPXSBTC".to_owned(),
            &CurrencyPair::NpxsEth => "NPXSETH".to_owned(),
            &CurrencyPair::NpxsUsdc => "NPXSUSDC".to_owned(),
            &CurrencyPair::NpxsUsdt => "NPXSUSDT".to_owned(),
            &CurrencyPair::NulsBnb => "NULSBNB".to_owned(),
            &CurrencyPair::NulsBtc => "NULSBTC".to_owned(),
            &CurrencyPair::NulsEth => "NULSETH".to_owned(),
            &CurrencyPair::NulsUsdt => "NULSUSDT".to_owned(),
            &CurrencyPair::NxsBnb => "NXSBNB".to_owned(),
            &CurrencyPair::NxsBtc => "NXSBTC".to_owned(),
            &CurrencyPair::NxsEth => "NXSETH".to_owned(),
            &CurrencyPair::OaxBtc => "OAXBTC".to_owned(),
            &CurrencyPair::OaxEth => "OAXETH".to_owned(),
            &CurrencyPair::OmgBnb => "OMGBNB".to_owned(),
            &CurrencyPair::OmgBtc => "OMGBTC".to_owned(),
            &CurrencyPair::OmgEth => "OMGETH".to_owned(),
            &CurrencyPair::OmgUsdt => "OMGUSDT".to_owned(),
            &CurrencyPair::OneBnb => "ONEBNB".to_owned(),
            &CurrencyPair::OneBtc => "ONEBTC".to_owned(),
            &CurrencyPair::OnePax => "ONEPAX".to_owned(),
            &CurrencyPair::OneTusd => "ONETUSD".to_owned(),
            &CurrencyPair::OneUsdc => "ONEUSDC".to_owned(),
            &CurrencyPair::OneUsdt => "ONEUSDT".to_owned(),
            &CurrencyPair::OngBnb => "ONGBNB".to_owned(),
            &CurrencyPair::OngBtc => "ONGBTC".to_owned(),
            &CurrencyPair::OngUsdt => "ONGUSDT".to_owned(),
            &CurrencyPair::OntBnb => "ONTBNB".to_owned(),
            &CurrencyPair::OntBtc => "ONTBTC".to_owned(),
            &CurrencyPair::OntEth => "ONTETH".to_owned(),
            &CurrencyPair::OntPax => "ONTPAX".to_owned(),
            &CurrencyPair::OntUsdc => "ONTUSDC".to_owned(),
            &CurrencyPair::OntUsdt => "ONTUSDT".to_owned(),
            &CurrencyPair::OstBnb => "OSTBNB".to_owned(),
            &CurrencyPair::OstBtc => "OSTBTC".to_owned(),
            &CurrencyPair::OstEth => "OSTETH".to_owned(),
            &CurrencyPair::PaxBnb => "PAXBNB".to_owned(),
            &CurrencyPair::PaxBtc => "PAXBTC".to_owned(),
            &CurrencyPair::PaxEth => "PAXETH".to_owned(),
            &CurrencyPair::PaxTusd => "PAXTUSD".to_owned(),
            &CurrencyPair::PaxUsdt => "PAXUSDT".to_owned(),
            &CurrencyPair::PerlBnb => "PERLBNB".to_owned(),
            &CurrencyPair::PerlBtc => "PERLBTC".to_owned(),
            &CurrencyPair::PerlUsdc => "PERLUSDC".to_owned(),
            &CurrencyPair::PerlUsdt => "PERLUSDT".to_owned(),
            &CurrencyPair::PhbBnb => "PHBBNB".to_owned(),
            &CurrencyPair::PhbBtc => "PHBBTC".to_owned(),
            &CurrencyPair::PhbPax => "PHBPAX".to_owned(),
            &CurrencyPair::PhbTusd => "PHBTUSD".to_owned(),
            &CurrencyPair::PhbUsdc => "PHBUSDC".to_owned(),
            &CurrencyPair::PhxBnb => "PHXBNB".to_owned(),
            &CurrencyPair::PhxBtc => "PHXBTC".to_owned(),
            &CurrencyPair::PhxEth => "PHXETH".to_owned(),
            &CurrencyPair::PivxBnb => "PIVXBNB".to_owned(),
            &CurrencyPair::PivxBtc => "PIVXBTC".to_owned(),
            &CurrencyPair::PivxEth => "PIVXETH".to_owned(),
            &CurrencyPair::PoaBnb => "POABNB".to_owned(),
            &CurrencyPair::PoaBtc => "POABTC".to_owned(),
            &CurrencyPair::PoaEth => "POAETH".to_owned(),
            &CurrencyPair::PoeBtc => "POEBTC".to_owned(),
            &CurrencyPair::PoeEth => "POEETH".to_owned(),
            &CurrencyPair::PolyBnb => "POLYBNB".to_owned(),
            &CurrencyPair::PolyBtc => "POLYBTC".to_owned(),
            &CurrencyPair::PowrBnb => "POWRBNB".to_owned(),
            &CurrencyPair::PowrBtc => "POWRBTC".to_owned(),
            &CurrencyPair::PowrEth => "POWRETH".to_owned(),
            &CurrencyPair::PptBtc => "PPTBTC".to_owned(),
            &CurrencyPair::PptEth => "PPTETH".to_owned(),
            &CurrencyPair::QkcBtc => "QKCBTC".to_owned(),
            &CurrencyPair::QkcEth => "QKCETH".to_owned(),
            &CurrencyPair::QlcBnb => "QLCBNB".to_owned(),
            &CurrencyPair::QlcBtc => "QLCBTC".to_owned(),
            &CurrencyPair::QlcEth => "QLCETH".to_owned(),
            &CurrencyPair::QspBnb => "QSPBNB".to_owned(),
            &CurrencyPair::QspBtc => "QSPBTC".to_owned(),
            &CurrencyPair::QspEth => "QSPETH".to_owned(),
            &CurrencyPair::QtumBnb => "QTUMBNB".to_owned(),
            &CurrencyPair::QtumBtc => "QTUMBTC".to_owned(),
            &CurrencyPair::QtumBusd => "QTUMBUSD".to_owned(),
            &CurrencyPair::QtumEth => "QTUMETH".to_owned(),
            &CurrencyPair::QtumUsdt => "QTUMUSDT".to_owned(),
            &CurrencyPair::RcnBnb => "RCNBNB".to_owned(),
            &CurrencyPair::RcnBtc => "RCNBTC".to_owned(),
            &CurrencyPair::RcnEth => "RCNETH".to_owned(),
            &CurrencyPair::RdnBnb => "RDNBNB".to_owned(),
            &CurrencyPair::RdnBtc => "RDNBTC".to_owned(),
            &CurrencyPair::RdnEth => "RDNETH".to_owned(),
            &CurrencyPair::RenBnb => "RENBNB".to_owned(),
            &CurrencyPair::RenBtc => "RENBTC".to_owned(),
            &CurrencyPair::RenUsdt => "RENUSDT".to_owned(),
            &CurrencyPair::RepBnb => "REPBNB".to_owned(),
            &CurrencyPair::RepBtc => "REPBTC".to_owned(),
            &CurrencyPair::RepEth => "REPETH".to_owned(),
            &CurrencyPair::ReqBtc => "REQBTC".to_owned(),
            &CurrencyPair::ReqEth => "REQETH".to_owned(),
            &CurrencyPair::RlcBnb => "RLCBNB".to_owned(),
            &CurrencyPair::RlcBtc => "RLCBTC".to_owned(),
            &CurrencyPair::RlcEth => "RLCETH".to_owned(),
            &CurrencyPair::RlcUsdt => "RLCUSDT".to_owned(),
            &CurrencyPair::RpxBnb => "RPXBNB".to_owned(),
            &CurrencyPair::RpxBtc => "RPXBTC".to_owned(),
            &CurrencyPair::RpxEth => "RPXETH".to_owned(),
            &CurrencyPair::RvnBnb => "RVNBNB".to_owned(),
            &CurrencyPair::RvnBtc => "RVNBTC".to_owned(),
            &CurrencyPair::RvnUsdt => "RVNUSDT".to_owned(),
            &CurrencyPair::SaltBtc => "SALTBTC".to_owned(),
            &CurrencyPair::SaltEth => "SALTETH".to_owned(),
            &CurrencyPair::ScBnb => "SCBNB".to_owned(),
            &CurrencyPair::ScBtc => "SCBTC".to_owned(),
            &CurrencyPair::ScEth => "SCETH".to_owned(),
            &CurrencyPair::SkyBnb => "SKYBNB".to_owned(),
            &CurrencyPair::SkyBtc => "SKYBTC".to_owned(),
            &CurrencyPair::SkyEth => "SKYETH".to_owned(),
            &CurrencyPair::SnglsBtc => "SNGLSBTC".to_owned(),
            &CurrencyPair::SnglsEth => "SNGLSETH".to_owned(),
            &CurrencyPair::SnmBtc => "SNMBTC".to_owned(),
            &CurrencyPair::SnmEth => "SNMETH".to_owned(),
            &CurrencyPair::SntBtc => "SNTBTC".to_owned(),
            &CurrencyPair::SntEth => "SNTETH".to_owned(),
            &CurrencyPair::SteemBnb => "STEEMBNB".to_owned(),
            &CurrencyPair::SteemBtc => "STEEMBTC".to_owned(),
            &CurrencyPair::SteemEth => "STEEMETH".to_owned(),
            &CurrencyPair::StorjBtc => "STORJBTC".to_owned(),
            &CurrencyPair::StorjEth => "STORJETH".to_owned(),
            &CurrencyPair::StormBnb => "STORMBNB".to_owned(),
            &CurrencyPair::StormBtc => "STORMBTC".to_owned(),
            &CurrencyPair::StormEth => "STORMETH".to_owned(),
            &CurrencyPair::StormUsdt => "STORMUSDT".to_owned(),
            &CurrencyPair::StratBtc => "STRATBTC".to_owned(),
            &CurrencyPair::StratEth => "STRATETH".to_owned(),
            &CurrencyPair::StxBnb => "STXBNB".to_owned(),
            &CurrencyPair::StxBtc => "STXBTC".to_owned(),
            &CurrencyPair::StxUsdt => "STXUSDT".to_owned(),
            &CurrencyPair::SubBtc => "SUBBTC".to_owned(),
            &CurrencyPair::SubEth => "SUBETH".to_owned(),
            &CurrencyPair::SysBnb => "SYSBNB".to_owned(),
            &CurrencyPair::SysBtc => "SYSBTC".to_owned(),
            &CurrencyPair::SysEth => "SYSETH".to_owned(),
            &CurrencyPair::TfuelBnb => "TFUELBNB".to_owned(),
            &CurrencyPair::TfuelBtc => "TFUELBTC".to_owned(),
            &CurrencyPair::TfuelPax => "TFUELPAX".to_owned(),
            &CurrencyPair::TfuelTusd => "TFUELTUSD".to_owned(),
            &CurrencyPair::TfuelUsdc => "TFUELUSDC".to_owned(),
            &CurrencyPair::TfuelUsdt => "TFUELUSDT".to_owned(),
            &CurrencyPair::ThetaBnb => "THETABNB".to_owned(),
            &CurrencyPair::ThetaBtc => "THETABTC".to_owned(),
            &CurrencyPair::ThetaEth => "THETAETH".to_owned(),
            &CurrencyPair::ThetaUsdt => "THETAUSDT".to_owned(),
            &CurrencyPair::TnbBtc => "TNBBTC".to_owned(),
            &CurrencyPair::TnbEth => "TNBETH".to_owned(),
            &CurrencyPair::TntBtc => "TNTBTC".to_owned(),
            &CurrencyPair::TntEth => "TNTETH".to_owned(),
            &CurrencyPair::TomoBnb => "TOMOBNB".to_owned(),
            &CurrencyPair::TomoBtc => "TOMOBTC".to_owned(),
            &CurrencyPair::TomoUsdc => "TOMOUSDC".to_owned(),
            &CurrencyPair::TomoUsdt => "TOMOUSDT".to_owned(),
            &CurrencyPair::TrigBnb => "TRIGBNB".to_owned(),
            &CurrencyPair::TrigBtc => "TRIGBTC".to_owned(),
            &CurrencyPair::TrigEth => "TRIGETH".to_owned(),
            &CurrencyPair::TroyBnb => "TROYBNB".to_owned(),
            &CurrencyPair::TroyBtc => "TROYBTC".to_owned(),
            &CurrencyPair::TroyUsdt => "TROYUSDT".to_owned(),
            &CurrencyPair::TrxBnb => "TRXBNB".to_owned(),
            &CurrencyPair::TrxBtc => "TRXBTC".to_owned(),
            &CurrencyPair::TrxBusd => "TRXBUSD".to_owned(),
            &CurrencyPair::TrxEth => "TRXETH".to_owned(),
            &CurrencyPair::TrxPax => "TRXPAX".to_owned(),
            &CurrencyPair::TrxTusd => "TRXTUSD".to_owned(),
            &CurrencyPair::TrxUsdc => "TRXUSDC".to_owned(),
            &CurrencyPair::TrxUsdt => "TRXUSDT".to_owned(),
            &CurrencyPair::TrxXrp => "TRXXRP".to_owned(),
            &CurrencyPair::TusdbTusd => "TUSDBTUSD".to_owned(),
            &CurrencyPair::TusdBnb => "TUSDBNB".to_owned(),
            &CurrencyPair::TusdBtc => "TUSDBTC".to_owned(),
            &CurrencyPair::TusdEth => "TUSDETH".to_owned(),
            &CurrencyPair::TusdUsdt => "TUSDUSDT".to_owned(),
            &CurrencyPair::UsdcBnb => "USDCBNB".to_owned(),
            &CurrencyPair::UsdcDash => "USDCDASH".to_owned(),
            &CurrencyPair::UsdcGrin => "USDCGRIN".to_owned(),
            &CurrencyPair::UsdcPax => "USDCPAX".to_owned(),
            &CurrencyPair::UsdcStr => "USDCSTR".to_owned(),
            &CurrencyPair::UsdcTusd => "USDCTUSD".to_owned(),
            &CurrencyPair::UsdcUsdt => "USDCUSDT".to_owned(),
            &CurrencyPair::UsdcXmr => "USDCXMR".to_owned(),
            &CurrencyPair::UsdsbUsds => "USDSBUSDS".to_owned(),
            &CurrencyPair::UsdsbUsdt => "USDSBUSDT".to_owned(),
            &CurrencyPair::UsdsPax => "USDSPAX".to_owned(),
            &CurrencyPair::UsdsTusd => "USDSTUSD".to_owned(),
            &CurrencyPair::UsdsUsdc => "USDSUSDC".to_owned(),
            &CurrencyPair::UsdsUsdt => "USDSUSDT".to_owned(),
            &CurrencyPair::UsdtDgb => "USDTDGB".to_owned(),
            &CurrencyPair::UsdtGnt => "USDTGNT".to_owned(),
            &CurrencyPair::UsdtGrin => "USDTGRIN".to_owned(),
            &CurrencyPair::UsdtLsk => "USDTLSK".to_owned(),
            &CurrencyPair::UsdtMana => "USDTMANA".to_owned(),
            &CurrencyPair::UsdtNxt => "USDTNXT".to_owned(),
            &CurrencyPair::UsdtRep => "USDTREP".to_owned(),
            &CurrencyPair::UsdtRub => "USDTRUB".to_owned(),
            &CurrencyPair::UsdtSc => "USDTSC".to_owned(),
            &CurrencyPair::UsdtStr => "USDTSTR".to_owned(),
            &CurrencyPair::UsdtTry => "USDTTRY".to_owned(),
            &CurrencyPair::VenBnb => "VENBNB".to_owned(),
            &CurrencyPair::VenBtc => "VENBTC".to_owned(),
            &CurrencyPair::VenEth => "VENETH".to_owned(),
            &CurrencyPair::VenUsdt => "VENUSDT".to_owned(),
            &CurrencyPair::VetBnb => "VETBNB".to_owned(),
            &CurrencyPair::VetBtc => "VETBTC".to_owned(),
            &CurrencyPair::VetBusd => "VETBUSD".to_owned(),
            &CurrencyPair::VetEth => "VETETH".to_owned(),
            &CurrencyPair::VetUsdt => "VETUSDT".to_owned(),
            &CurrencyPair::ViaBnb => "VIABNB".to_owned(),
            &CurrencyPair::ViaBtc => "VIABTC".to_owned(),
            &CurrencyPair::ViaEth => "VIAETH".to_owned(),
            &CurrencyPair::VibeBtc => "VIBEBTC".to_owned(),
            &CurrencyPair::VibeEth => "VIBEETH".to_owned(),
            &CurrencyPair::VibBtc => "VIBBTC".to_owned(),
            &CurrencyPair::VibEth => "VIBETH".to_owned(),
            &CurrencyPair::ViteBnb => "VITEBNB".to_owned(),
            &CurrencyPair::ViteBtc => "VITEBTC".to_owned(),
            &CurrencyPair::ViteUsdt => "VITEUSDT".to_owned(),
            &CurrencyPair::WabiBnb => "WABIBNB".to_owned(),
            &CurrencyPair::WabiBtc => "WABIBTC".to_owned(),
            &CurrencyPair::WabiEth => "WABIETH".to_owned(),
            &CurrencyPair::WanBnb => "WANBNB".to_owned(),
            &CurrencyPair::WanBtc => "WANBTC".to_owned(),
            &CurrencyPair::WanEth => "WANETH".to_owned(),
            &CurrencyPair::WanUsdt => "WANUSDT".to_owned(),
            &CurrencyPair::WavesBnb => "WAVESBNB".to_owned(),
            &CurrencyPair::WavesBtc => "WAVESBTC".to_owned(),
            &CurrencyPair::WavesEth => "WAVESETH".to_owned(),
            &CurrencyPair::WavesPax => "WAVESPAX".to_owned(),
            &CurrencyPair::WavesTusd => "WAVESTUSD".to_owned(),
            &CurrencyPair::WavesUsdc => "WAVESUSDC".to_owned(),
            &CurrencyPair::WavesUsdt => "WAVESUSDT".to_owned(),
            &CurrencyPair::WingsBtc => "WINGSBTC".to_owned(),
            &CurrencyPair::WingsEth => "WINGSETH".to_owned(),
            &CurrencyPair::WinBnb => "WINBNB".to_owned(),
            &CurrencyPair::WinBtc => "WINBTC".to_owned(),
            &CurrencyPair::WinTrx => "WINTRX".to_owned(),
            &CurrencyPair::WinUsdc => "WINUSDC".to_owned(),
            &CurrencyPair::WinUsdt => "WINUSDT".to_owned(),
            &CurrencyPair::WprBtc => "WPRBTC".to_owned(),
            &CurrencyPair::WprEth => "WPRETH".to_owned(),
            &CurrencyPair::WtcBnb => "WTCBNB".to_owned(),
            &CurrencyPair::WtcBtc => "WTCBTC".to_owned(),
            &CurrencyPair::WtcEth => "WTCETH".to_owned(),
            &CurrencyPair::XemBnb => "XEMBNB".to_owned(),
            &CurrencyPair::XemBtc => "XEMBTC".to_owned(),
            &CurrencyPair::XemEth => "XEMETH".to_owned(),
            &CurrencyPair::XlmBnb => "XLMBNB".to_owned(),
            &CurrencyPair::XlmBtc => "XLMBTC".to_owned(),
            &CurrencyPair::XlmBusd => "XLMBUSD".to_owned(),
            &CurrencyPair::XlmEth => "XLMETH".to_owned(),
            &CurrencyPair::XlmPax => "XLMPAX".to_owned(),
            &CurrencyPair::XlmTusd => "XLMTUSD".to_owned(),
            &CurrencyPair::XlmUsdc => "XLMUSDC".to_owned(),
            &CurrencyPair::XlmUsdt => "XLMUSDT".to_owned(),
            &CurrencyPair::XmrBnb => "XMRBNB".to_owned(),
            &CurrencyPair::XmrBtc => "XMRBTC".to_owned(),
            &CurrencyPair::XmrEth => "XMRETH".to_owned(),
            &CurrencyPair::XmrUsdt => "XMRUSDT".to_owned(),
            &CurrencyPair::XrpBnb => "XRPBNB".to_owned(),
            &CurrencyPair::XrpBtc => "XRPBTC".to_owned(),
            &CurrencyPair::XrpBusd => "XRPBUSD".to_owned(),
            &CurrencyPair::XrpEth => "XRPETH".to_owned(),
            &CurrencyPair::XrpPax => "XRPPAX".to_owned(),
            &CurrencyPair::XrpRub => "XRPRUB".to_owned(),
            &CurrencyPair::XrpTry => "XRPTRY".to_owned(),
            &CurrencyPair::XrpTusd => "XRPTUSD".to_owned(),
            &CurrencyPair::XrpUsdc => "XRPUSDC".to_owned(),
            &CurrencyPair::XrpUsdt => "XRPUSDT".to_owned(),
            &CurrencyPair::XtzBnb => "XTZBNB".to_owned(),
            &CurrencyPair::XtzBtc => "XTZBTC".to_owned(),
            &CurrencyPair::XtzUsdt => "XTZUSDT".to_owned(),
            &CurrencyPair::XvgBtc => "XVGBTC".to_owned(),
            &CurrencyPair::XvgEth => "XVGETH".to_owned(),
            &CurrencyPair::XzcBnb => "XZCBNB".to_owned(),
            &CurrencyPair::XzcBtc => "XZCBTC".to_owned(),
            &CurrencyPair::XzcEth => "XZCETH".to_owned(),
            &CurrencyPair::XzcXrp => "XZCXRP".to_owned(),
            &CurrencyPair::YoyoBnb => "YOYOBNB".to_owned(),
            &CurrencyPair::YoyoBtc => "YOYOBTC".to_owned(),
            &CurrencyPair::YoyoEth => "YOYOETH".to_owned(),
            &CurrencyPair::ZecBnb => "ZECBNB".to_owned(),
            &CurrencyPair::ZecBtc => "ZECBTC".to_owned(),
            &CurrencyPair::ZecEth => "ZECETH".to_owned(),
            &CurrencyPair::ZecPax => "ZECPAX".to_owned(),
            &CurrencyPair::ZecTusd => "ZECTUSD".to_owned(),
            &CurrencyPair::ZecUsdc => "ZECUSDC".to_owned(),
            &CurrencyPair::ZecUsdt => "ZECUSDT".to_owned(),
            &CurrencyPair::ZenBnb => "ZENBNB".to_owned(),
            &CurrencyPair::ZenBtc => "ZENBTC".to_owned(),
            &CurrencyPair::ZenEth => "ZENETH".to_owned(),
            &CurrencyPair::ZilBnb => "ZILBNB".to_owned(),
            &CurrencyPair::ZilBtc => "ZILBTC".to_owned(),
            &CurrencyPair::ZilEth => "ZILETH".to_owned(),
            &CurrencyPair::ZilUsdt => "ZILUSDT".to_owned(),
            &CurrencyPair::ZrxBnb => "ZRXBNB".to_owned(),
            &CurrencyPair::ZrxBtc => "ZRXBTC".to_owned(),
            &CurrencyPair::ZrxEth => "ZRXETH".to_owned(),
            &CurrencyPair::ZrxUsdt => "ZRXUSDT".to_owned(),
        }
    }

    pub fn join_reversed(&self) -> String {
        match self {
            CurrencyPair::Custom(_, ref quote, ref base) => format!("{}_{}", base, quote),
            &CurrencyPair::AdaBnb => "BNB_ADA".to_owned(),
            &CurrencyPair::AdaBtc => "BTC_ADA".to_owned(),
            &CurrencyPair::AdaBusd => "BUSD_ADA".to_owned(),
            &CurrencyPair::AdaEth => "ETH_ADA".to_owned(),
            &CurrencyPair::AdaPax => "PAX_ADA".to_owned(),
            &CurrencyPair::AdaTusd => "TUSD_ADA".to_owned(),
            &CurrencyPair::AdaUsdc => "USDC_ADA".to_owned(),
            &CurrencyPair::AdaUsdt => "USDT_ADA".to_owned(),
            &CurrencyPair::AdxBnb => "BNB_ADX".to_owned(),
            &CurrencyPair::AdxBtc => "BTC_ADX".to_owned(),
            &CurrencyPair::AdxEth => "ETH_ADX".to_owned(),
            &CurrencyPair::AeBnb => "BNB_AE".to_owned(),
            &CurrencyPair::AeBtc => "BTC_AE".to_owned(),
            &CurrencyPair::AeEth => "ETH_AE".to_owned(),
            &CurrencyPair::AgiBnb => "BNB_AGI".to_owned(),
            &CurrencyPair::AgiBtc => "BTC_AGI".to_owned(),
            &CurrencyPair::AgiEth => "ETH_AGI".to_owned(),
            &CurrencyPair::AionBnb => "BNB_AION".to_owned(),
            &CurrencyPair::AionBtc => "BTC_AION".to_owned(),
            &CurrencyPair::AionEth => "ETH_AION".to_owned(),
            &CurrencyPair::AlgoBnb => "BNB_ALGO".to_owned(),
            &CurrencyPair::AlgoBtc => "BTC_ALGO".to_owned(),
            &CurrencyPair::AlgoPax => "PAX_ALGO".to_owned(),
            &CurrencyPair::AlgoTusd => "TUSD_ALGO".to_owned(),
            &CurrencyPair::AlgoUsdc => "USDC_ALGO".to_owned(),
            &CurrencyPair::AlgoUsdt => "USDT_ALGO".to_owned(),
            &CurrencyPair::AmbBnb => "BNB_AMB".to_owned(),
            &CurrencyPair::AmbBtc => "BTC_AMB".to_owned(),
            &CurrencyPair::AmbEth => "ETH_AMB".to_owned(),
            &CurrencyPair::AnkrBnb => "BNB_ANKR".to_owned(),
            &CurrencyPair::AnkrBtc => "BTC_ANKR".to_owned(),
            &CurrencyPair::AnkrPax => "PAX_ANKR".to_owned(),
            &CurrencyPair::AnkrTusd => "TUSD_ANKR".to_owned(),
            &CurrencyPair::AnkrUsdc => "USDC_ANKR".to_owned(),
            &CurrencyPair::AnkrUsdt => "USDT_ANKR".to_owned(),
            &CurrencyPair::AppcBnb => "BNB_APPC".to_owned(),
            &CurrencyPair::AppcBtc => "BTC_APPC".to_owned(),
            &CurrencyPair::AppcEth => "ETH_APPC".to_owned(),
            &CurrencyPair::ArdrBnb => "BNB_ARDR".to_owned(),
            &CurrencyPair::ArdrBtc => "BTC_ARDR".to_owned(),
            &CurrencyPair::ArdrEth => "ETH_ARDR".to_owned(),
            &CurrencyPair::ArkBtc => "BTC_ARK".to_owned(),
            &CurrencyPair::ArkEth => "ETH_ARK".to_owned(),
            &CurrencyPair::ArnBtc => "BTC_ARN".to_owned(),
            &CurrencyPair::ArnEth => "ETH_ARN".to_owned(),
            &CurrencyPair::ArpaBnb => "BNB_ARPA".to_owned(),
            &CurrencyPair::ArpaBtc => "BTC_ARPA".to_owned(),
            &CurrencyPair::ArpaUsdt => "USDT_ARPA".to_owned(),
            &CurrencyPair::AstBtc => "BTC_AST".to_owned(),
            &CurrencyPair::AstEth => "ETH_AST".to_owned(),
            &CurrencyPair::AtomBnb => "BNB_ATOM".to_owned(),
            &CurrencyPair::AtomBtc => "BTC_ATOM".to_owned(),
            &CurrencyPair::AtomPax => "PAX_ATOM".to_owned(),
            &CurrencyPair::AtomTusd => "TUSD_ATOM".to_owned(),
            &CurrencyPair::AtomUsdc => "USDC_ATOM".to_owned(),
            &CurrencyPair::AtomUsdt => "USDT_ATOM".to_owned(),
            &CurrencyPair::BandBnb => "BNB_BAND".to_owned(),
            &CurrencyPair::BandBtc => "BTC_BAND".to_owned(),
            &CurrencyPair::BandUsdt => "USDT_BAND".to_owned(),
            &CurrencyPair::BatBnb => "BNB_BAT".to_owned(),
            &CurrencyPair::BatBtc => "BTC_BAT".to_owned(),
            &CurrencyPair::BatEth => "ETH_BAT".to_owned(),
            &CurrencyPair::BatPax => "PAX_BAT".to_owned(),
            &CurrencyPair::BatTusd => "TUSD_BAT".to_owned(),
            &CurrencyPair::BatUsdc => "USDC_BAT".to_owned(),
            &CurrencyPair::BatUsdt => "USDT_BAT".to_owned(),
            &CurrencyPair::BccBnb => "BNB_BCC".to_owned(),
            &CurrencyPair::BccBtc => "BTC_BCC".to_owned(),
            &CurrencyPair::BccEth => "ETH_BCC".to_owned(),
            &CurrencyPair::BccUsdt => "USDT_BCC".to_owned(),
            &CurrencyPair::BcdBtc => "BTC_BCD".to_owned(),
            &CurrencyPair::BcdEth => "ETH_BCD".to_owned(),
            &CurrencyPair::BchabcBtc => "BTC_BCHABC".to_owned(),
            &CurrencyPair::BchabcBusd => "BUSD_BCHABC".to_owned(),
            &CurrencyPair::BchabcPax => "PAX_BCHABC".to_owned(),
            &CurrencyPair::BchabcTusd => "TUSD_BCHABC".to_owned(),
            &CurrencyPair::BchabcUsdc => "USDC_BCHABC".to_owned(),
            &CurrencyPair::BchabcUsdt => "USDT_BCHABC".to_owned(),
            &CurrencyPair::BchsvBtc => "BTC_BCHSV".to_owned(),
            &CurrencyPair::BchsvPax => "PAX_BCHSV".to_owned(),
            &CurrencyPair::BchsvTusd => "TUSD_BCHSV".to_owned(),
            &CurrencyPair::BchsvUsdc => "USDC_BCHSV".to_owned(),
            &CurrencyPair::BchsvUsdt => "USDT_BCHSV".to_owned(),
            &CurrencyPair::BchBnb => "BNB_BCH".to_owned(),
            &CurrencyPair::BchBtc => "BTC_BCH".to_owned(),
            &CurrencyPair::BchBusd => "BUSD_BCH".to_owned(),
            &CurrencyPair::BchPax => "PAX_BCH".to_owned(),
            &CurrencyPair::BchTusd => "TUSD_BCH".to_owned(),
            &CurrencyPair::BchUsdc => "USDC_BCH".to_owned(),
            &CurrencyPair::BchUsdt => "USDT_BCH".to_owned(),
            &CurrencyPair::BcnBnb => "BNB_BCN".to_owned(),
            &CurrencyPair::BcnBtc => "BTC_BCN".to_owned(),
            &CurrencyPair::BcnEth => "ETH_BCN".to_owned(),
            &CurrencyPair::BcptBnb => "BNB_BCPT".to_owned(),
            &CurrencyPair::BcptBtc => "BTC_BCPT".to_owned(),
            &CurrencyPair::BcptEth => "ETH_BCPT".to_owned(),
            &CurrencyPair::BcptPax => "PAX_BCPT".to_owned(),
            &CurrencyPair::BcptTusd => "TUSD_BCPT".to_owned(),
            &CurrencyPair::BcptUsdc => "USDC_BCPT".to_owned(),
            &CurrencyPair::BeamBnb => "BNB_BEAM".to_owned(),
            &CurrencyPair::BeamBtc => "BTC_BEAM".to_owned(),
            &CurrencyPair::BeamUsdt => "USDT_BEAM".to_owned(),
            &CurrencyPair::BgbpUsdc => "USDC_BGBP".to_owned(),
            &CurrencyPair::BlzBnb => "BNB_BLZ".to_owned(),
            &CurrencyPair::BlzBtc => "BTC_BLZ".to_owned(),
            &CurrencyPair::BlzEth => "ETH_BLZ".to_owned(),
            &CurrencyPair::BnbBtc => "BTC_BNB".to_owned(),
            &CurrencyPair::BnbBusd => "BUSD_BNB".to_owned(),
            &CurrencyPair::BnbEth => "ETH_BNB".to_owned(),
            &CurrencyPair::BnbNgn => "NGN_BNB".to_owned(),
            &CurrencyPair::BnbPax => "PAX_BNB".to_owned(),
            &CurrencyPair::BnbRub => "RUB_BNB".to_owned(),
            &CurrencyPair::BnbTry => "TRY_BNB".to_owned(),
            &CurrencyPair::BnbTusd => "TUSD_BNB".to_owned(),
            &CurrencyPair::BnbUsdc => "USDC_BNB".to_owned(),
            &CurrencyPair::BnbUsds => "USDS_BNB".to_owned(),
            &CurrencyPair::BnbUsdt => "USDT_BNB".to_owned(),
            &CurrencyPair::BntBtc => "BTC_BNT".to_owned(),
            &CurrencyPair::BntEth => "ETH_BNT".to_owned(),
            &CurrencyPair::BqxBtc => "BTC_BQX".to_owned(),
            &CurrencyPair::BqxEth => "ETH_BQX".to_owned(),
            &CurrencyPair::BrdBnb => "BNB_BRD".to_owned(),
            &CurrencyPair::BrdBtc => "BTC_BRD".to_owned(),
            &CurrencyPair::BrdEth => "ETH_BRD".to_owned(),
            &CurrencyPair::BtcbBtc => "BTC_BTCB".to_owned(),
            &CurrencyPair::BtcBusd => "BUSD_BTC".to_owned(),
            &CurrencyPair::BtcDgb => "DGB_BTC".to_owned(),
            &CurrencyPair::BtcFct => "FCT_BTC".to_owned(),
            &CurrencyPair::BtcFoam => "FOAM_BTC".to_owned(),
            &CurrencyPair::BtcGrin => "GRIN_BTC".to_owned(),
            &CurrencyPair::BtcLpt => "LPT_BTC".to_owned(),
            &CurrencyPair::BtcMaid => "MAID_BTC".to_owned(),
            &CurrencyPair::BtcNgn => "NGN_BTC".to_owned(),
            &CurrencyPair::BtcNmr => "NMR_BTC".to_owned(),
            &CurrencyPair::BtcNxt => "NXT_BTC".to_owned(),
            &CurrencyPair::BtcOmni => "OMNI_BTC".to_owned(),
            &CurrencyPair::BtcPax => "PAX_BTC".to_owned(),
            &CurrencyPair::BtcRub => "RUB_BTC".to_owned(),
            &CurrencyPair::BtcStr => "STR_BTC".to_owned(),
            &CurrencyPair::BtcTry => "TRY_BTC".to_owned(),
            &CurrencyPair::BtcTusd => "TUSD_BTC".to_owned(),
            &CurrencyPair::BtcUsdc => "USDC_BTC".to_owned(),
            &CurrencyPair::BtcUsds => "USDS_BTC".to_owned(),
            &CurrencyPair::BtcUsdt => "USDT_BTC".to_owned(),
            &CurrencyPair::BtcVtc => "VTC_BTC".to_owned(),
            &CurrencyPair::BtcXpm => "XPM_BTC".to_owned(),
            &CurrencyPair::BtgBtc => "BTC_BTG".to_owned(),
            &CurrencyPair::BtgEth => "ETH_BTG".to_owned(),
            &CurrencyPair::BtsBnb => "BNB_BTS".to_owned(),
            &CurrencyPair::BtsBtc => "BTC_BTS".to_owned(),
            &CurrencyPair::BtsEth => "ETH_BTS".to_owned(),
            &CurrencyPair::BttBnb => "BNB_BTT".to_owned(),
            &CurrencyPair::BttBtc => "BTC_BTT".to_owned(),
            &CurrencyPair::BttPax => "PAX_BTT".to_owned(),
            &CurrencyPair::BttTrx => "TRX_BTT".to_owned(),
            &CurrencyPair::BttTusd => "TUSD_BTT".to_owned(),
            &CurrencyPair::BttUsdc => "USDC_BTT".to_owned(),
            &CurrencyPair::BttUsdt => "USDT_BTT".to_owned(),
            &CurrencyPair::BusdNgn => "NGN_BUSD".to_owned(),
            &CurrencyPair::BusdRub => "RUB_BUSD".to_owned(),
            &CurrencyPair::BusdTry => "TRY_BUSD".to_owned(),
            &CurrencyPair::BusdUsdt => "USDT_BUSD".to_owned(),
            &CurrencyPair::CdtBtc => "BTC_CDT".to_owned(),
            &CurrencyPair::CdtEth => "ETH_CDT".to_owned(),
            &CurrencyPair::CelrBnb => "BNB_CELR".to_owned(),
            &CurrencyPair::CelrBtc => "BTC_CELR".to_owned(),
            &CurrencyPair::CelrUsdt => "USDT_CELR".to_owned(),
            &CurrencyPair::ChatBtc => "BTC_CHAT".to_owned(),
            &CurrencyPair::ChatEth => "ETH_CHAT".to_owned(),
            &CurrencyPair::ChzBnb => "BNB_CHZ".to_owned(),
            &CurrencyPair::ChzBtc => "BTC_CHZ".to_owned(),
            &CurrencyPair::ChzUsdt => "USDT_CHZ".to_owned(),
            &CurrencyPair::CloakBtc => "BTC_CLOAK".to_owned(),
            &CurrencyPair::CloakEth => "ETH_CLOAK".to_owned(),
            &CurrencyPair::CmtBnb => "BNB_CMT".to_owned(),
            &CurrencyPair::CmtBtc => "BTC_CMT".to_owned(),
            &CurrencyPair::CmtEth => "ETH_CMT".to_owned(),
            &CurrencyPair::CndBnb => "BNB_CND".to_owned(),
            &CurrencyPair::CndBtc => "BTC_CND".to_owned(),
            &CurrencyPair::CndEth => "ETH_CND".to_owned(),
            &CurrencyPair::CocosBnb => "BNB_COCOS".to_owned(),
            &CurrencyPair::CocosBtc => "BTC_COCOS".to_owned(),
            &CurrencyPair::CocosUsdt => "USDT_COCOS".to_owned(),
            &CurrencyPair::CosBnb => "BNB_COS".to_owned(),
            &CurrencyPair::CosBtc => "BTC_COS".to_owned(),
            &CurrencyPair::CosUsdt => "USDT_COS".to_owned(),
            &CurrencyPair::CtxcBnb => "BNB_CTXC".to_owned(),
            &CurrencyPair::CtxcBtc => "BTC_CTXC".to_owned(),
            &CurrencyPair::CtxcUsdt => "USDT_CTXC".to_owned(),
            &CurrencyPair::CvcBnb => "BNB_CVC".to_owned(),
            &CurrencyPair::CvcBtc => "BTC_CVC".to_owned(),
            &CurrencyPair::CvcEth => "ETH_CVC".to_owned(),
            &CurrencyPair::CvcUsdt => "USDT_CVC".to_owned(),
            &CurrencyPair::DashBnb => "BNB_DASH".to_owned(),
            &CurrencyPair::DashBtc => "BTC_DASH".to_owned(),
            &CurrencyPair::DashEth => "ETH_DASH".to_owned(),
            &CurrencyPair::DashUsdt => "USDT_DASH".to_owned(),
            &CurrencyPair::DataBtc => "BTC_DATA".to_owned(),
            &CurrencyPair::DataEth => "ETH_DATA".to_owned(),
            &CurrencyPair::DcrBnb => "BNB_DCR".to_owned(),
            &CurrencyPair::DcrBtc => "BTC_DCR".to_owned(),
            &CurrencyPair::DentBtc => "BTC_DENT".to_owned(),
            &CurrencyPair::DentEth => "ETH_DENT".to_owned(),
            &CurrencyPair::DentUsdt => "USDT_DENT".to_owned(),
            &CurrencyPair::DgdBtc => "BTC_DGD".to_owned(),
            &CurrencyPair::DgdEth => "ETH_DGD".to_owned(),
            &CurrencyPair::DltBnb => "BNB_DLT".to_owned(),
            &CurrencyPair::DltBtc => "BTC_DLT".to_owned(),
            &CurrencyPair::DltEth => "ETH_DLT".to_owned(),
            &CurrencyPair::DntBtc => "BTC_DNT".to_owned(),
            &CurrencyPair::DntEth => "ETH_DNT".to_owned(),
            &CurrencyPair::DockBtc => "BTC_DOCK".to_owned(),
            &CurrencyPair::DockEth => "ETH_DOCK".to_owned(),
            &CurrencyPair::DockUsdt => "USDT_DOCK".to_owned(),
            &CurrencyPair::DogeBnb => "BNB_DOGE".to_owned(),
            &CurrencyPair::DogeBtc => "BTC_DOGE".to_owned(),
            &CurrencyPair::DogePax => "PAX_DOGE".to_owned(),
            &CurrencyPair::DogeUsdc => "USDC_DOGE".to_owned(),
            &CurrencyPair::DogeUsdt => "USDT_DOGE".to_owned(),
            &CurrencyPair::DuskBnb => "BNB_DUSK".to_owned(),
            &CurrencyPair::DuskBtc => "BTC_DUSK".to_owned(),
            &CurrencyPair::DuskPax => "PAX_DUSK".to_owned(),
            &CurrencyPair::DuskUsdc => "USDC_DUSK".to_owned(),
            &CurrencyPair::DuskUsdt => "USDT_DUSK".to_owned(),
            &CurrencyPair::EdoBtc => "BTC_EDO".to_owned(),
            &CurrencyPair::EdoEth => "ETH_EDO".to_owned(),
            &CurrencyPair::ElfBtc => "BTC_ELF".to_owned(),
            &CurrencyPair::ElfEth => "ETH_ELF".to_owned(),
            &CurrencyPair::EngBtc => "BTC_ENG".to_owned(),
            &CurrencyPair::EngEth => "ETH_ENG".to_owned(),
            &CurrencyPair::EnjBnb => "BNB_ENJ".to_owned(),
            &CurrencyPair::EnjBtc => "BTC_ENJ".to_owned(),
            &CurrencyPair::EnjEth => "ETH_ENJ".to_owned(),
            &CurrencyPair::EnjUsdt => "USDT_ENJ".to_owned(),
            &CurrencyPair::EosBnb => "BNB_EOS".to_owned(),
            &CurrencyPair::EosBtc => "BTC_EOS".to_owned(),
            &CurrencyPair::EosBusd => "BUSD_EOS".to_owned(),
            &CurrencyPair::EosEth => "ETH_EOS".to_owned(),
            &CurrencyPair::EosPax => "PAX_EOS".to_owned(),
            &CurrencyPair::EosTusd => "TUSD_EOS".to_owned(),
            &CurrencyPair::EosUsdc => "USDC_EOS".to_owned(),
            &CurrencyPair::EosUsdt => "USDT_EOS".to_owned(),
            &CurrencyPair::ErdBnb => "BNB_ERD".to_owned(),
            &CurrencyPair::ErdBtc => "BTC_ERD".to_owned(),
            &CurrencyPair::ErdPax => "PAX_ERD".to_owned(),
            &CurrencyPair::ErdUsdc => "USDC_ERD".to_owned(),
            &CurrencyPair::ErdUsdt => "USDT_ERD".to_owned(),
            &CurrencyPair::EtcBnb => "BNB_ETC".to_owned(),
            &CurrencyPair::EtcBtc => "BTC_ETC".to_owned(),
            &CurrencyPair::EtcBusd => "BUSD_ETC".to_owned(),
            &CurrencyPair::EtcEth => "ETH_ETC".to_owned(),
            &CurrencyPair::EtcPax => "PAX_ETC".to_owned(),
            &CurrencyPair::EtcTusd => "TUSD_ETC".to_owned(),
            &CurrencyPair::EtcUsdc => "USDC_ETC".to_owned(),
            &CurrencyPair::EtcUsdt => "USDT_ETC".to_owned(),
            &CurrencyPair::EthBtc => "BTC_ETH".to_owned(),
            &CurrencyPair::EthBusd => "BUSD_ETH".to_owned(),
            &CurrencyPair::EthPax => "PAX_ETH".to_owned(),
            &CurrencyPair::EthRub => "RUB_ETH".to_owned(),
            &CurrencyPair::EthTry => "TRY_ETH".to_owned(),
            &CurrencyPair::EthTusd => "TUSD_ETH".to_owned(),
            &CurrencyPair::EthUsdc => "USDC_ETH".to_owned(),
            &CurrencyPair::EthUsdt => "USDT_ETH".to_owned(),
            &CurrencyPair::EvxBtc => "BTC_EVX".to_owned(),
            &CurrencyPair::EvxEth => "ETH_EVX".to_owned(),
            &CurrencyPair::FetBnb => "BNB_FET".to_owned(),
            &CurrencyPair::FetBtc => "BTC_FET".to_owned(),
            &CurrencyPair::FetUsdt => "USDT_FET".to_owned(),
            &CurrencyPair::FtmBnb => "BNB_FTM".to_owned(),
            &CurrencyPair::FtmBtc => "BTC_FTM".to_owned(),
            &CurrencyPair::FtmPax => "PAX_FTM".to_owned(),
            &CurrencyPair::FtmTusd => "TUSD_FTM".to_owned(),
            &CurrencyPair::FtmUsdc => "USDC_FTM".to_owned(),
            &CurrencyPair::FtmUsdt => "USDT_FTM".to_owned(),
            &CurrencyPair::FttBnb => "BNB_FTT".to_owned(),
            &CurrencyPair::FttBtc => "BTC_FTT".to_owned(),
            &CurrencyPair::FttUsdt => "USDT_FTT".to_owned(),
            &CurrencyPair::FuelBtc => "BTC_FUEL".to_owned(),
            &CurrencyPair::FuelEth => "ETH_FUEL".to_owned(),
            &CurrencyPair::FunBtc => "BTC_FUN".to_owned(),
            &CurrencyPair::FunEth => "ETH_FUN".to_owned(),
            &CurrencyPair::FunUsdt => "USDT_FUN".to_owned(),
            &CurrencyPair::GasBtc => "BTC_GAS".to_owned(),
            &CurrencyPair::GntBnb => "BNB_GNT".to_owned(),
            &CurrencyPair::GntBtc => "BTC_GNT".to_owned(),
            &CurrencyPair::GntEth => "ETH_GNT".to_owned(),
            &CurrencyPair::GoBnb => "BNB_GO".to_owned(),
            &CurrencyPair::GoBtc => "BTC_GO".to_owned(),
            &CurrencyPair::GrsBtc => "BTC_GRS".to_owned(),
            &CurrencyPair::GrsEth => "ETH_GRS".to_owned(),
            &CurrencyPair::GtoBnb => "BNB_GTO".to_owned(),
            &CurrencyPair::GtoBtc => "BTC_GTO".to_owned(),
            &CurrencyPair::GtoEth => "ETH_GTO".to_owned(),
            &CurrencyPair::GtoPax => "PAX_GTO".to_owned(),
            &CurrencyPair::GtoTusd => "TUSD_GTO".to_owned(),
            &CurrencyPair::GtoUsdc => "USDC_GTO".to_owned(),
            &CurrencyPair::GtoUsdt => "USDT_GTO".to_owned(),
            &CurrencyPair::GvtBtc => "BTC_GVT".to_owned(),
            &CurrencyPair::GvtEth => "ETH_GVT".to_owned(),
            &CurrencyPair::GxsBtc => "BTC_GXS".to_owned(),
            &CurrencyPair::GxsEth => "ETH_GXS".to_owned(),
            &CurrencyPair::HbarBnb => "BNB_HBAR".to_owned(),
            &CurrencyPair::HbarBtc => "BTC_HBAR".to_owned(),
            &CurrencyPair::HbarUsdt => "USDT_HBAR".to_owned(),
            &CurrencyPair::HcBtc => "BTC_HC".to_owned(),
            &CurrencyPair::HcEth => "ETH_HC".to_owned(),
            &CurrencyPair::HcUsdt => "USDT_HC".to_owned(),
            &CurrencyPair::HotBnb => "BNB_HOT".to_owned(),
            &CurrencyPair::HotBtc => "BTC_HOT".to_owned(),
            &CurrencyPair::HotEth => "ETH_HOT".to_owned(),
            &CurrencyPair::HotUsdt => "USDT_HOT".to_owned(),
            &CurrencyPair::HsrBtc => "BTC_HSR".to_owned(),
            &CurrencyPair::HsrEth => "ETH_HSR".to_owned(),
            &CurrencyPair::IcnBtc => "BTC_ICN".to_owned(),
            &CurrencyPair::IcnEth => "ETH_ICN".to_owned(),
            &CurrencyPair::IcxBnb => "BNB_ICX".to_owned(),
            &CurrencyPair::IcxBtc => "BTC_ICX".to_owned(),
            &CurrencyPair::IcxEth => "ETH_ICX".to_owned(),
            &CurrencyPair::IcxUsdt => "USDT_ICX".to_owned(),
            &CurrencyPair::InsBtc => "BTC_INS".to_owned(),
            &CurrencyPair::InsEth => "ETH_INS".to_owned(),
            &CurrencyPair::IostBnb => "BNB_IOST".to_owned(),
            &CurrencyPair::IostBtc => "BTC_IOST".to_owned(),
            &CurrencyPair::IostEth => "ETH_IOST".to_owned(),
            &CurrencyPair::IostUsdt => "USDT_IOST".to_owned(),
            &CurrencyPair::IotaBnb => "BNB_IOTA".to_owned(),
            &CurrencyPair::IotaBtc => "BTC_IOTA".to_owned(),
            &CurrencyPair::IotaEth => "ETH_IOTA".to_owned(),
            &CurrencyPair::IotaUsdt => "USDT_IOTA".to_owned(),
            &CurrencyPair::IotxBtc => "BTC_IOTX".to_owned(),
            &CurrencyPair::IotxEth => "ETH_IOTX".to_owned(),
            &CurrencyPair::IotxUsdt => "USDT_IOTX".to_owned(),
            &CurrencyPair::KavaBnb => "BNB_KAVA".to_owned(),
            &CurrencyPair::KavaBtc => "BTC_KAVA".to_owned(),
            &CurrencyPair::KavaUsdt => "USDT_KAVA".to_owned(),
            &CurrencyPair::KeyBtc => "BTC_KEY".to_owned(),
            &CurrencyPair::KeyEth => "ETH_KEY".to_owned(),
            &CurrencyPair::KeyUsdt => "USDT_KEY".to_owned(),
            &CurrencyPair::KmdBtc => "BTC_KMD".to_owned(),
            &CurrencyPair::KmdEth => "ETH_KMD".to_owned(),
            &CurrencyPair::KncBtc => "BTC_KNC".to_owned(),
            &CurrencyPair::KncEth => "ETH_KNC".to_owned(),
            &CurrencyPair::LendBtc => "BTC_LEND".to_owned(),
            &CurrencyPair::LendEth => "ETH_LEND".to_owned(),
            &CurrencyPair::LinkBtc => "BTC_LINK".to_owned(),
            &CurrencyPair::LinkBusd => "BUSD_LINK".to_owned(),
            &CurrencyPair::LinkEth => "ETH_LINK".to_owned(),
            &CurrencyPair::LinkPax => "PAX_LINK".to_owned(),
            &CurrencyPair::LinkTusd => "TUSD_LINK".to_owned(),
            &CurrencyPair::LinkUsdc => "USDC_LINK".to_owned(),
            &CurrencyPair::LinkUsdt => "USDT_LINK".to_owned(),
            &CurrencyPair::LoomBnb => "BNB_LOOM".to_owned(),
            &CurrencyPair::LoomBtc => "BTC_LOOM".to_owned(),
            &CurrencyPair::LoomEth => "ETH_LOOM".to_owned(),
            &CurrencyPair::LrcBtc => "BTC_LRC".to_owned(),
            &CurrencyPair::LrcEth => "ETH_LRC".to_owned(),
            &CurrencyPair::LskBnb => "BNB_LSK".to_owned(),
            &CurrencyPair::LskBtc => "BTC_LSK".to_owned(),
            &CurrencyPair::LskEth => "ETH_LSK".to_owned(),
            &CurrencyPair::LtcBnb => "BNB_LTC".to_owned(),
            &CurrencyPair::LtcBtc => "BTC_LTC".to_owned(),
            &CurrencyPair::LtcBusd => "BUSD_LTC".to_owned(),
            &CurrencyPair::LtcEth => "ETH_LTC".to_owned(),
            &CurrencyPair::LtcPax => "PAX_LTC".to_owned(),
            &CurrencyPair::LtcTusd => "TUSD_LTC".to_owned(),
            &CurrencyPair::LtcUsdc => "USDC_LTC".to_owned(),
            &CurrencyPair::LtcUsdt => "USDT_LTC".to_owned(),
            &CurrencyPair::LunBtc => "BTC_LUN".to_owned(),
            &CurrencyPair::LunEth => "ETH_LUN".to_owned(),
            &CurrencyPair::ManaBtc => "BTC_MANA".to_owned(),
            &CurrencyPair::ManaEth => "ETH_MANA".to_owned(),
            &CurrencyPair::MaticBnb => "BNB_MATIC".to_owned(),
            &CurrencyPair::MaticBtc => "BTC_MATIC".to_owned(),
            &CurrencyPair::MaticUsdt => "USDT_MATIC".to_owned(),
            &CurrencyPair::McoBnb => "BNB_MCO".to_owned(),
            &CurrencyPair::McoBtc => "BTC_MCO".to_owned(),
            &CurrencyPair::McoEth => "ETH_MCO".to_owned(),
            &CurrencyPair::McoUsdt => "USDT_MCO".to_owned(),
            &CurrencyPair::MdaBtc => "BTC_MDA".to_owned(),
            &CurrencyPair::MdaEth => "ETH_MDA".to_owned(),
            &CurrencyPair::MftBnb => "BNB_MFT".to_owned(),
            &CurrencyPair::MftBtc => "BTC_MFT".to_owned(),
            &CurrencyPair::MftEth => "ETH_MFT".to_owned(),
            &CurrencyPair::MftUsdt => "USDT_MFT".to_owned(),
            &CurrencyPair::MithBnb => "BNB_MITH".to_owned(),
            &CurrencyPair::MithBtc => "BTC_MITH".to_owned(),
            &CurrencyPair::MithUsdt => "USDT_MITH".to_owned(),
            &CurrencyPair::ModBtc => "BTC_MOD".to_owned(),
            &CurrencyPair::ModEth => "ETH_MOD".to_owned(),
            &CurrencyPair::MthBtc => "BTC_MTH".to_owned(),
            &CurrencyPair::MthEth => "ETH_MTH".to_owned(),
            &CurrencyPair::MtlBtc => "BTC_MTL".to_owned(),
            &CurrencyPair::MtlEth => "ETH_MTL".to_owned(),
            &CurrencyPair::MtlUsdt => "USDT_MTL".to_owned(),
            &CurrencyPair::NanoBnb => "BNB_NANO".to_owned(),
            &CurrencyPair::NanoBtc => "BTC_NANO".to_owned(),
            &CurrencyPair::NanoEth => "ETH_NANO".to_owned(),
            &CurrencyPair::NanoUsdt => "USDT_NANO".to_owned(),
            &CurrencyPair::NasBnb => "BNB_NAS".to_owned(),
            &CurrencyPair::NasBtc => "BTC_NAS".to_owned(),
            &CurrencyPair::NasEth => "ETH_NAS".to_owned(),
            &CurrencyPair::NavBnb => "BNB_NAV".to_owned(),
            &CurrencyPair::NavBtc => "BTC_NAV".to_owned(),
            &CurrencyPair::NavEth => "ETH_NAV".to_owned(),
            &CurrencyPair::NcashBnb => "BNB_NCASH".to_owned(),
            &CurrencyPair::NcashBtc => "BTC_NCASH".to_owned(),
            &CurrencyPair::NcashEth => "ETH_NCASH".to_owned(),
            &CurrencyPair::NeblBnb => "BNB_NEBL".to_owned(),
            &CurrencyPair::NeblBtc => "BTC_NEBL".to_owned(),
            &CurrencyPair::NeblEth => "ETH_NEBL".to_owned(),
            &CurrencyPair::NeoBnb => "BNB_NEO".to_owned(),
            &CurrencyPair::NeoBtc => "BTC_NEO".to_owned(),
            &CurrencyPair::NeoEth => "ETH_NEO".to_owned(),
            &CurrencyPair::NeoPax => "PAX_NEO".to_owned(),
            &CurrencyPair::NeoTusd => "TUSD_NEO".to_owned(),
            &CurrencyPair::NeoUsdc => "USDC_NEO".to_owned(),
            &CurrencyPair::NeoUsdt => "USDT_NEO".to_owned(),
            &CurrencyPair::NknBnb => "BNB_NKN".to_owned(),
            &CurrencyPair::NknBtc => "BTC_NKN".to_owned(),
            &CurrencyPair::NknUsdt => "USDT_NKN".to_owned(),
            &CurrencyPair::NpxsBtc => "BTC_NPXS".to_owned(),
            &CurrencyPair::NpxsEth => "ETH_NPXS".to_owned(),
            &CurrencyPair::NpxsUsdc => "USDC_NPXS".to_owned(),
            &CurrencyPair::NpxsUsdt => "USDT_NPXS".to_owned(),
            &CurrencyPair::NulsBnb => "BNB_NULS".to_owned(),
            &CurrencyPair::NulsBtc => "BTC_NULS".to_owned(),
            &CurrencyPair::NulsEth => "ETH_NULS".to_owned(),
            &CurrencyPair::NulsUsdt => "USDT_NULS".to_owned(),
            &CurrencyPair::NxsBnb => "BNB_NXS".to_owned(),
            &CurrencyPair::NxsBtc => "BTC_NXS".to_owned(),
            &CurrencyPair::NxsEth => "ETH_NXS".to_owned(),
            &CurrencyPair::OaxBtc => "BTC_OAX".to_owned(),
            &CurrencyPair::OaxEth => "ETH_OAX".to_owned(),
            &CurrencyPair::OmgBnb => "BNB_OMG".to_owned(),
            &CurrencyPair::OmgBtc => "BTC_OMG".to_owned(),
            &CurrencyPair::OmgEth => "ETH_OMG".to_owned(),
            &CurrencyPair::OmgUsdt => "USDT_OMG".to_owned(),
            &CurrencyPair::OneBnb => "BNB_ONE".to_owned(),
            &CurrencyPair::OneBtc => "BTC_ONE".to_owned(),
            &CurrencyPair::OnePax => "PAX_ONE".to_owned(),
            &CurrencyPair::OneTusd => "TUSD_ONE".to_owned(),
            &CurrencyPair::OneUsdc => "USDC_ONE".to_owned(),
            &CurrencyPair::OneUsdt => "USDT_ONE".to_owned(),
            &CurrencyPair::OngBnb => "BNB_ONG".to_owned(),
            &CurrencyPair::OngBtc => "BTC_ONG".to_owned(),
            &CurrencyPair::OngUsdt => "USDT_ONG".to_owned(),
            &CurrencyPair::OntBnb => "BNB_ONT".to_owned(),
            &CurrencyPair::OntBtc => "BTC_ONT".to_owned(),
            &CurrencyPair::OntEth => "ETH_ONT".to_owned(),
            &CurrencyPair::OntPax => "PAX_ONT".to_owned(),
            &CurrencyPair::OntUsdc => "USDC_ONT".to_owned(),
            &CurrencyPair::OntUsdt => "USDT_ONT".to_owned(),
            &CurrencyPair::OstBnb => "BNB_OST".to_owned(),
            &CurrencyPair::OstBtc => "BTC_OST".to_owned(),
            &CurrencyPair::OstEth => "ETH_OST".to_owned(),
            &CurrencyPair::PaxBnb => "BNB_PAX".to_owned(),
            &CurrencyPair::PaxBtc => "BTC_PAX".to_owned(),
            &CurrencyPair::PaxEth => "ETH_PAX".to_owned(),
            &CurrencyPair::PaxTusd => "TUSD_PAX".to_owned(),
            &CurrencyPair::PaxUsdt => "USDT_PAX".to_owned(),
            &CurrencyPair::PerlBnb => "BNB_PERL".to_owned(),
            &CurrencyPair::PerlBtc => "BTC_PERL".to_owned(),
            &CurrencyPair::PerlUsdc => "USDC_PERL".to_owned(),
            &CurrencyPair::PerlUsdt => "USDT_PERL".to_owned(),
            &CurrencyPair::PhbBnb => "BNB_PHB".to_owned(),
            &CurrencyPair::PhbBtc => "BTC_PHB".to_owned(),
            &CurrencyPair::PhbPax => "PAX_PHB".to_owned(),
            &CurrencyPair::PhbTusd => "TUSD_PHB".to_owned(),
            &CurrencyPair::PhbUsdc => "USDC_PHB".to_owned(),
            &CurrencyPair::PhxBnb => "BNB_PHX".to_owned(),
            &CurrencyPair::PhxBtc => "BTC_PHX".to_owned(),
            &CurrencyPair::PhxEth => "ETH_PHX".to_owned(),
            &CurrencyPair::PivxBnb => "BNB_PIVX".to_owned(),
            &CurrencyPair::PivxBtc => "BTC_PIVX".to_owned(),
            &CurrencyPair::PivxEth => "ETH_PIVX".to_owned(),
            &CurrencyPair::PoaBnb => "BNB_POA".to_owned(),
            &CurrencyPair::PoaBtc => "BTC_POA".to_owned(),
            &CurrencyPair::PoaEth => "ETH_POA".to_owned(),
            &CurrencyPair::PoeBtc => "BTC_POE".to_owned(),
            &CurrencyPair::PoeEth => "ETH_POE".to_owned(),
            &CurrencyPair::PolyBnb => "BNB_POLY".to_owned(),
            &CurrencyPair::PolyBtc => "BTC_POLY".to_owned(),
            &CurrencyPair::PowrBnb => "BNB_POWR".to_owned(),
            &CurrencyPair::PowrBtc => "BTC_POWR".to_owned(),
            &CurrencyPair::PowrEth => "ETH_POWR".to_owned(),
            &CurrencyPair::PptBtc => "BTC_PPT".to_owned(),
            &CurrencyPair::PptEth => "ETH_PPT".to_owned(),
            &CurrencyPair::QkcBtc => "BTC_QKC".to_owned(),
            &CurrencyPair::QkcEth => "ETH_QKC".to_owned(),
            &CurrencyPair::QlcBnb => "BNB_QLC".to_owned(),
            &CurrencyPair::QlcBtc => "BTC_QLC".to_owned(),
            &CurrencyPair::QlcEth => "ETH_QLC".to_owned(),
            &CurrencyPair::QspBnb => "BNB_QSP".to_owned(),
            &CurrencyPair::QspBtc => "BTC_QSP".to_owned(),
            &CurrencyPair::QspEth => "ETH_QSP".to_owned(),
            &CurrencyPair::QtumBnb => "BNB_QTUM".to_owned(),
            &CurrencyPair::QtumBtc => "BTC_QTUM".to_owned(),
            &CurrencyPair::QtumBusd => "BUSD_QTUM".to_owned(),
            &CurrencyPair::QtumEth => "ETH_QTUM".to_owned(),
            &CurrencyPair::QtumUsdt => "USDT_QTUM".to_owned(),
            &CurrencyPair::RcnBnb => "BNB_RCN".to_owned(),
            &CurrencyPair::RcnBtc => "BTC_RCN".to_owned(),
            &CurrencyPair::RcnEth => "ETH_RCN".to_owned(),
            &CurrencyPair::RdnBnb => "BNB_RDN".to_owned(),
            &CurrencyPair::RdnBtc => "BTC_RDN".to_owned(),
            &CurrencyPair::RdnEth => "ETH_RDN".to_owned(),
            &CurrencyPair::RenBnb => "BNB_REN".to_owned(),
            &CurrencyPair::RenBtc => "BTC_REN".to_owned(),
            &CurrencyPair::RenUsdt => "USDT_REN".to_owned(),
            &CurrencyPair::RepBnb => "BNB_REP".to_owned(),
            &CurrencyPair::RepBtc => "BTC_REP".to_owned(),
            &CurrencyPair::RepEth => "ETH_REP".to_owned(),
            &CurrencyPair::ReqBtc => "BTC_REQ".to_owned(),
            &CurrencyPair::ReqEth => "ETH_REQ".to_owned(),
            &CurrencyPair::RlcBnb => "BNB_RLC".to_owned(),
            &CurrencyPair::RlcBtc => "BTC_RLC".to_owned(),
            &CurrencyPair::RlcEth => "ETH_RLC".to_owned(),
            &CurrencyPair::RlcUsdt => "USDT_RLC".to_owned(),
            &CurrencyPair::RpxBnb => "BNB_RPX".to_owned(),
            &CurrencyPair::RpxBtc => "BTC_RPX".to_owned(),
            &CurrencyPair::RpxEth => "ETH_RPX".to_owned(),
            &CurrencyPair::RvnBnb => "BNB_RVN".to_owned(),
            &CurrencyPair::RvnBtc => "BTC_RVN".to_owned(),
            &CurrencyPair::RvnUsdt => "USDT_RVN".to_owned(),
            &CurrencyPair::SaltBtc => "BTC_SALT".to_owned(),
            &CurrencyPair::SaltEth => "ETH_SALT".to_owned(),
            &CurrencyPair::ScBnb => "BNB_SC".to_owned(),
            &CurrencyPair::ScBtc => "BTC_SC".to_owned(),
            &CurrencyPair::ScEth => "ETH_SC".to_owned(),
            &CurrencyPair::SkyBnb => "BNB_SKY".to_owned(),
            &CurrencyPair::SkyBtc => "BTC_SKY".to_owned(),
            &CurrencyPair::SkyEth => "ETH_SKY".to_owned(),
            &CurrencyPair::SnglsBtc => "BTC_SNGLS".to_owned(),
            &CurrencyPair::SnglsEth => "ETH_SNGLS".to_owned(),
            &CurrencyPair::SnmBtc => "BTC_SNM".to_owned(),
            &CurrencyPair::SnmEth => "ETH_SNM".to_owned(),
            &CurrencyPair::SntBtc => "BTC_SNT".to_owned(),
            &CurrencyPair::SntEth => "ETH_SNT".to_owned(),
            &CurrencyPair::SteemBnb => "BNB_STEEM".to_owned(),
            &CurrencyPair::SteemBtc => "BTC_STEEM".to_owned(),
            &CurrencyPair::SteemEth => "ETH_STEEM".to_owned(),
            &CurrencyPair::StorjBtc => "BTC_STORJ".to_owned(),
            &CurrencyPair::StorjEth => "ETH_STORJ".to_owned(),
            &CurrencyPair::StormBnb => "BNB_STORM".to_owned(),
            &CurrencyPair::StormBtc => "BTC_STORM".to_owned(),
            &CurrencyPair::StormEth => "ETH_STORM".to_owned(),
            &CurrencyPair::StormUsdt => "USDT_STORM".to_owned(),
            &CurrencyPair::StratBtc => "BTC_STRAT".to_owned(),
            &CurrencyPair::StratEth => "ETH_STRAT".to_owned(),
            &CurrencyPair::StxBnb => "BNB_STX".to_owned(),
            &CurrencyPair::StxBtc => "BTC_STX".to_owned(),
            &CurrencyPair::StxUsdt => "USDT_STX".to_owned(),
            &CurrencyPair::SubBtc => "BTC_SUB".to_owned(),
            &CurrencyPair::SubEth => "ETH_SUB".to_owned(),
            &CurrencyPair::SysBnb => "BNB_SYS".to_owned(),
            &CurrencyPair::SysBtc => "BTC_SYS".to_owned(),
            &CurrencyPair::SysEth => "ETH_SYS".to_owned(),
            &CurrencyPair::TfuelBnb => "BNB_TFUEL".to_owned(),
            &CurrencyPair::TfuelBtc => "BTC_TFUEL".to_owned(),
            &CurrencyPair::TfuelPax => "PAX_TFUEL".to_owned(),
            &CurrencyPair::TfuelTusd => "TUSD_TFUEL".to_owned(),
            &CurrencyPair::TfuelUsdc => "USDC_TFUEL".to_owned(),
            &CurrencyPair::TfuelUsdt => "USDT_TFUEL".to_owned(),
            &CurrencyPair::ThetaBnb => "BNB_THETA".to_owned(),
            &CurrencyPair::ThetaBtc => "BTC_THETA".to_owned(),
            &CurrencyPair::ThetaEth => "ETH_THETA".to_owned(),
            &CurrencyPair::ThetaUsdt => "USDT_THETA".to_owned(),
            &CurrencyPair::TnbBtc => "BTC_TNB".to_owned(),
            &CurrencyPair::TnbEth => "ETH_TNB".to_owned(),
            &CurrencyPair::TntBtc => "BTC_TNT".to_owned(),
            &CurrencyPair::TntEth => "ETH_TNT".to_owned(),
            &CurrencyPair::TomoBnb => "BNB_TOMO".to_owned(),
            &CurrencyPair::TomoBtc => "BTC_TOMO".to_owned(),
            &CurrencyPair::TomoUsdc => "USDC_TOMO".to_owned(),
            &CurrencyPair::TomoUsdt => "USDT_TOMO".to_owned(),
            &CurrencyPair::TrigBnb => "BNB_TRIG".to_owned(),
            &CurrencyPair::TrigBtc => "BTC_TRIG".to_owned(),
            &CurrencyPair::TrigEth => "ETH_TRIG".to_owned(),
            &CurrencyPair::TroyBnb => "BNB_TROY".to_owned(),
            &CurrencyPair::TroyBtc => "BTC_TROY".to_owned(),
            &CurrencyPair::TroyUsdt => "USDT_TROY".to_owned(),
            &CurrencyPair::TrxBnb => "BNB_TRX".to_owned(),
            &CurrencyPair::TrxBtc => "BTC_TRX".to_owned(),
            &CurrencyPair::TrxBusd => "BUSD_TRX".to_owned(),
            &CurrencyPair::TrxEth => "ETH_TRX".to_owned(),
            &CurrencyPair::TrxPax => "PAX_TRX".to_owned(),
            &CurrencyPair::TrxTusd => "TUSD_TRX".to_owned(),
            &CurrencyPair::TrxUsdc => "USDC_TRX".to_owned(),
            &CurrencyPair::TrxUsdt => "USDT_TRX".to_owned(),
            &CurrencyPair::TrxXrp => "XRP_TRX".to_owned(),
            &CurrencyPair::TusdbTusd => "TUSD_TUSDB".to_owned(),
            &CurrencyPair::TusdBnb => "BNB_TUSD".to_owned(),
            &CurrencyPair::TusdBtc => "BTC_TUSD".to_owned(),
            &CurrencyPair::TusdEth => "ETH_TUSD".to_owned(),
            &CurrencyPair::TusdUsdt => "USDT_TUSD".to_owned(),
            &CurrencyPair::UsdcBnb => "BNB_USDC".to_owned(),
            &CurrencyPair::UsdcDash => "DASH_USDC".to_owned(),
            &CurrencyPair::UsdcGrin => "GRIN_USDC".to_owned(),
            &CurrencyPair::UsdcPax => "PAX_USDC".to_owned(),
            &CurrencyPair::UsdcStr => "STR_USDC".to_owned(),
            &CurrencyPair::UsdcTusd => "TUSD_USDC".to_owned(),
            &CurrencyPair::UsdcUsdt => "USDT_USDC".to_owned(),
            &CurrencyPair::UsdcXmr => "XMR_USDC".to_owned(),
            &CurrencyPair::UsdsbUsds => "USDS_USDSB".to_owned(),
            &CurrencyPair::UsdsbUsdt => "USDT_USDSB".to_owned(),
            &CurrencyPair::UsdsPax => "PAX_USDS".to_owned(),
            &CurrencyPair::UsdsTusd => "TUSD_USDS".to_owned(),
            &CurrencyPair::UsdsUsdc => "USDC_USDS".to_owned(),
            &CurrencyPair::UsdsUsdt => "USDT_USDS".to_owned(),
            &CurrencyPair::UsdtDgb => "DGB_USDT".to_owned(),
            &CurrencyPair::UsdtGnt => "GNT_USDT".to_owned(),
            &CurrencyPair::UsdtGrin => "GRIN_USDT".to_owned(),
            &CurrencyPair::UsdtLsk => "LSK_USDT".to_owned(),
            &CurrencyPair::UsdtMana => "MANA_USDT".to_owned(),
            &CurrencyPair::UsdtNxt => "NXT_USDT".to_owned(),
            &CurrencyPair::UsdtRep => "REP_USDT".to_owned(),
            &CurrencyPair::UsdtRub => "RUB_USDT".to_owned(),
            &CurrencyPair::UsdtSc => "SC_USDT".to_owned(),
            &CurrencyPair::UsdtStr => "STR_USDT".to_owned(),
            &CurrencyPair::UsdtTry => "TRY_USDT".to_owned(),
            &CurrencyPair::VenBnb => "BNB_VEN".to_owned(),
            &CurrencyPair::VenBtc => "BTC_VEN".to_owned(),
            &CurrencyPair::VenEth => "ETH_VEN".to_owned(),
            &CurrencyPair::VenUsdt => "USDT_VEN".to_owned(),
            &CurrencyPair::VetBnb => "BNB_VET".to_owned(),
            &CurrencyPair::VetBtc => "BTC_VET".to_owned(),
            &CurrencyPair::VetBusd => "BUSD_VET".to_owned(),
            &CurrencyPair::VetEth => "ETH_VET".to_owned(),
            &CurrencyPair::VetUsdt => "USDT_VET".to_owned(),
            &CurrencyPair::ViaBnb => "BNB_VIA".to_owned(),
            &CurrencyPair::ViaBtc => "BTC_VIA".to_owned(),
            &CurrencyPair::ViaEth => "ETH_VIA".to_owned(),
            &CurrencyPair::VibeBtc => "BTC_VIBE".to_owned(),
            &CurrencyPair::VibeEth => "ETH_VIBE".to_owned(),
            &CurrencyPair::VibBtc => "BTC_VIB".to_owned(),
            &CurrencyPair::VibEth => "ETH_VIB".to_owned(),
            &CurrencyPair::ViteBnb => "BNB_VITE".to_owned(),
            &CurrencyPair::ViteBtc => "BTC_VITE".to_owned(),
            &CurrencyPair::ViteUsdt => "USDT_VITE".to_owned(),
            &CurrencyPair::WabiBnb => "BNB_WABI".to_owned(),
            &CurrencyPair::WabiBtc => "BTC_WABI".to_owned(),
            &CurrencyPair::WabiEth => "ETH_WABI".to_owned(),
            &CurrencyPair::WanBnb => "BNB_WAN".to_owned(),
            &CurrencyPair::WanBtc => "BTC_WAN".to_owned(),
            &CurrencyPair::WanEth => "ETH_WAN".to_owned(),
            &CurrencyPair::WanUsdt => "USDT_WAN".to_owned(),
            &CurrencyPair::WavesBnb => "BNB_WAVES".to_owned(),
            &CurrencyPair::WavesBtc => "BTC_WAVES".to_owned(),
            &CurrencyPair::WavesEth => "ETH_WAVES".to_owned(),
            &CurrencyPair::WavesPax => "PAX_WAVES".to_owned(),
            &CurrencyPair::WavesTusd => "TUSD_WAVES".to_owned(),
            &CurrencyPair::WavesUsdc => "USDC_WAVES".to_owned(),
            &CurrencyPair::WavesUsdt => "USDT_WAVES".to_owned(),
            &CurrencyPair::WingsBtc => "BTC_WINGS".to_owned(),
            &CurrencyPair::WingsEth => "ETH_WINGS".to_owned(),
            &CurrencyPair::WinBnb => "BNB_WIN".to_owned(),
            &CurrencyPair::WinBtc => "BTC_WIN".to_owned(),
            &CurrencyPair::WinTrx => "TRX_WIN".to_owned(),
            &CurrencyPair::WinUsdc => "USDC_WIN".to_owned(),
            &CurrencyPair::WinUsdt => "USDT_WIN".to_owned(),
            &CurrencyPair::WprBtc => "BTC_WPR".to_owned(),
            &CurrencyPair::WprEth => "ETH_WPR".to_owned(),
            &CurrencyPair::WtcBnb => "BNB_WTC".to_owned(),
            &CurrencyPair::WtcBtc => "BTC_WTC".to_owned(),
            &CurrencyPair::WtcEth => "ETH_WTC".to_owned(),
            &CurrencyPair::XemBnb => "BNB_XEM".to_owned(),
            &CurrencyPair::XemBtc => "BTC_XEM".to_owned(),
            &CurrencyPair::XemEth => "ETH_XEM".to_owned(),
            &CurrencyPair::XlmBnb => "BNB_XLM".to_owned(),
            &CurrencyPair::XlmBtc => "BTC_XLM".to_owned(),
            &CurrencyPair::XlmBusd => "BUSD_XLM".to_owned(),
            &CurrencyPair::XlmEth => "ETH_XLM".to_owned(),
            &CurrencyPair::XlmPax => "PAX_XLM".to_owned(),
            &CurrencyPair::XlmTusd => "TUSD_XLM".to_owned(),
            &CurrencyPair::XlmUsdc => "USDC_XLM".to_owned(),
            &CurrencyPair::XlmUsdt => "USDT_XLM".to_owned(),
            &CurrencyPair::XmrBnb => "BNB_XMR".to_owned(),
            &CurrencyPair::XmrBtc => "BTC_XMR".to_owned(),
            &CurrencyPair::XmrEth => "ETH_XMR".to_owned(),
            &CurrencyPair::XmrUsdt => "USDT_XMR".to_owned(),
            &CurrencyPair::XrpBnb => "BNB_XRP".to_owned(),
            &CurrencyPair::XrpBtc => "BTC_XRP".to_owned(),
            &CurrencyPair::XrpBusd => "BUSD_XRP".to_owned(),
            &CurrencyPair::XrpEth => "ETH_XRP".to_owned(),
            &CurrencyPair::XrpPax => "PAX_XRP".to_owned(),
            &CurrencyPair::XrpRub => "RUB_XRP".to_owned(),
            &CurrencyPair::XrpTry => "TRY_XRP".to_owned(),
            &CurrencyPair::XrpTusd => "TUSD_XRP".to_owned(),
            &CurrencyPair::XrpUsdc => "USDC_XRP".to_owned(),
            &CurrencyPair::XrpUsdt => "USDT_XRP".to_owned(),
            &CurrencyPair::XtzBnb => "BNB_XTZ".to_owned(),
            &CurrencyPair::XtzBtc => "BTC_XTZ".to_owned(),
            &CurrencyPair::XtzUsdt => "USDT_XTZ".to_owned(),
            &CurrencyPair::XvgBtc => "BTC_XVG".to_owned(),
            &CurrencyPair::XvgEth => "ETH_XVG".to_owned(),
            &CurrencyPair::XzcBnb => "BNB_XZC".to_owned(),
            &CurrencyPair::XzcBtc => "BTC_XZC".to_owned(),
            &CurrencyPair::XzcEth => "ETH_XZC".to_owned(),
            &CurrencyPair::XzcXrp => "XRP_XZC".to_owned(),
            &CurrencyPair::YoyoBnb => "BNB_YOYO".to_owned(),
            &CurrencyPair::YoyoBtc => "BTC_YOYO".to_owned(),
            &CurrencyPair::YoyoEth => "ETH_YOYO".to_owned(),
            &CurrencyPair::ZecBnb => "BNB_ZEC".to_owned(),
            &CurrencyPair::ZecBtc => "BTC_ZEC".to_owned(),
            &CurrencyPair::ZecEth => "ETH_ZEC".to_owned(),
            &CurrencyPair::ZecPax => "PAX_ZEC".to_owned(),
            &CurrencyPair::ZecTusd => "TUSD_ZEC".to_owned(),
            &CurrencyPair::ZecUsdc => "USDC_ZEC".to_owned(),
            &CurrencyPair::ZecUsdt => "USDT_ZEC".to_owned(),
            &CurrencyPair::ZenBnb => "BNB_ZEN".to_owned(),
            &CurrencyPair::ZenBtc => "BTC_ZEN".to_owned(),
            &CurrencyPair::ZenEth => "ETH_ZEN".to_owned(),
            &CurrencyPair::ZilBnb => "BNB_ZIL".to_owned(),
            &CurrencyPair::ZilBtc => "BTC_ZIL".to_owned(),
            &CurrencyPair::ZilEth => "ETH_ZIL".to_owned(),
            &CurrencyPair::ZilUsdt => "USDT_ZIL".to_owned(),
            &CurrencyPair::ZrxBnb => "BNB_ZRX".to_owned(),
            &CurrencyPair::ZrxBtc => "BTC_ZRX".to_owned(),
            &CurrencyPair::ZrxEth => "ETH_ZRX".to_owned(),
            &CurrencyPair::ZrxUsdt => "USDT_ZRX".to_owned(),
        }
    }

    pub fn as_str(&self) -> &str {
        match self {
            CurrencyPair::Custom(ref s, _, _) => s,
            &CurrencyPair::AdaBnb => "ADA_BNB",
            &CurrencyPair::AdaBtc => "ADA_BTC",
            &CurrencyPair::AdaBusd => "ADA_BUSD",
            &CurrencyPair::AdaEth => "ADA_ETH",
            &CurrencyPair::AdaPax => "ADA_PAX",
            &CurrencyPair::AdaTusd => "ADA_TUSD",
            &CurrencyPair::AdaUsdc => "ADA_USDC",
            &CurrencyPair::AdaUsdt => "ADA_USDT",
            &CurrencyPair::AdxBnb => "ADX_BNB",
            &CurrencyPair::AdxBtc => "ADX_BTC",
            &CurrencyPair::AdxEth => "ADX_ETH",
            &CurrencyPair::AeBnb => "AE_BNB",
            &CurrencyPair::AeBtc => "AE_BTC",
            &CurrencyPair::AeEth => "AE_ETH",
            &CurrencyPair::AgiBnb => "AGI_BNB",
            &CurrencyPair::AgiBtc => "AGI_BTC",
            &CurrencyPair::AgiEth => "AGI_ETH",
            &CurrencyPair::AionBnb => "AION_BNB",
            &CurrencyPair::AionBtc => "AION_BTC",
            &CurrencyPair::AionEth => "AION_ETH",
            &CurrencyPair::AlgoBnb => "ALGO_BNB",
            &CurrencyPair::AlgoBtc => "ALGO_BTC",
            &CurrencyPair::AlgoPax => "ALGO_PAX",
            &CurrencyPair::AlgoTusd => "ALGO_TUSD",
            &CurrencyPair::AlgoUsdc => "ALGO_USDC",
            &CurrencyPair::AlgoUsdt => "ALGO_USDT",
            &CurrencyPair::AmbBnb => "AMB_BNB",
            &CurrencyPair::AmbBtc => "AMB_BTC",
            &CurrencyPair::AmbEth => "AMB_ETH",
            &CurrencyPair::AnkrBnb => "ANKR_BNB",
            &CurrencyPair::AnkrBtc => "ANKR_BTC",
            &CurrencyPair::AnkrPax => "ANKR_PAX",
            &CurrencyPair::AnkrTusd => "ANKR_TUSD",
            &CurrencyPair::AnkrUsdc => "ANKR_USDC",
            &CurrencyPair::AnkrUsdt => "ANKR_USDT",
            &CurrencyPair::AppcBnb => "APPC_BNB",
            &CurrencyPair::AppcBtc => "APPC_BTC",
            &CurrencyPair::AppcEth => "APPC_ETH",
            &CurrencyPair::ArdrBnb => "ARDR_BNB",
            &CurrencyPair::ArdrBtc => "ARDR_BTC",
            &CurrencyPair::ArdrEth => "ARDR_ETH",
            &CurrencyPair::ArkBtc => "ARK_BTC",
            &CurrencyPair::ArkEth => "ARK_ETH",
            &CurrencyPair::ArnBtc => "ARN_BTC",
            &CurrencyPair::ArnEth => "ARN_ETH",
            &CurrencyPair::ArpaBnb => "ARPA_BNB",
            &CurrencyPair::ArpaBtc => "ARPA_BTC",
            &CurrencyPair::ArpaUsdt => "ARPA_USDT",
            &CurrencyPair::AstBtc => "AST_BTC",
            &CurrencyPair::AstEth => "AST_ETH",
            &CurrencyPair::AtomBnb => "ATOM_BNB",
            &CurrencyPair::AtomBtc => "ATOM_BTC",
            &CurrencyPair::AtomPax => "ATOM_PAX",
            &CurrencyPair::AtomTusd => "ATOM_TUSD",
            &CurrencyPair::AtomUsdc => "ATOM_USDC",
            &CurrencyPair::AtomUsdt => "ATOM_USDT",
            &CurrencyPair::BandBnb => "BAND_BNB",
            &CurrencyPair::BandBtc => "BAND_BTC",
            &CurrencyPair::BandUsdt => "BAND_USDT",
            &CurrencyPair::BatBnb => "BAT_BNB",
            &CurrencyPair::BatBtc => "BAT_BTC",
            &CurrencyPair::BatEth => "BAT_ETH",
            &CurrencyPair::BatPax => "BAT_PAX",
            &CurrencyPair::BatTusd => "BAT_TUSD",
            &CurrencyPair::BatUsdc => "BAT_USDC",
            &CurrencyPair::BatUsdt => "BAT_USDT",
            &CurrencyPair::BccBnb => "BCC_BNB",
            &CurrencyPair::BccBtc => "BCC_BTC",
            &CurrencyPair::BccEth => "BCC_ETH",
            &CurrencyPair::BccUsdt => "BCC_USDT",
            &CurrencyPair::BcdBtc => "BCD_BTC",
            &CurrencyPair::BcdEth => "BCD_ETH",
            &CurrencyPair::BchabcBtc => "BCHABC_BTC",
            &CurrencyPair::BchabcBusd => "BCHABC_BUSD",
            &CurrencyPair::BchabcPax => "BCHABC_PAX",
            &CurrencyPair::BchabcTusd => "BCHABC_TUSD",
            &CurrencyPair::BchabcUsdc => "BCHABC_USDC",
            &CurrencyPair::BchabcUsdt => "BCHABC_USDT",
            &CurrencyPair::BchsvBtc => "BCHSV_BTC",
            &CurrencyPair::BchsvPax => "BCHSV_PAX",
            &CurrencyPair::BchsvTusd => "BCHSV_TUSD",
            &CurrencyPair::BchsvUsdc => "BCHSV_USDC",
            &CurrencyPair::BchsvUsdt => "BCHSV_USDT",
            &CurrencyPair::BchBnb => "BCH_BNB",
            &CurrencyPair::BchBtc => "BCH_BTC",
            &CurrencyPair::BchBusd => "BCH_BUSD",
            &CurrencyPair::BchPax => "BCH_PAX",
            &CurrencyPair::BchTusd => "BCH_TUSD",
            &CurrencyPair::BchUsdc => "BCH_USDC",
            &CurrencyPair::BchUsdt => "BCH_USDT",
            &CurrencyPair::BcnBnb => "BCN_BNB",
            &CurrencyPair::BcnBtc => "BCN_BTC",
            &CurrencyPair::BcnEth => "BCN_ETH",
            &CurrencyPair::BcptBnb => "BCPT_BNB",
            &CurrencyPair::BcptBtc => "BCPT_BTC",
            &CurrencyPair::BcptEth => "BCPT_ETH",
            &CurrencyPair::BcptPax => "BCPT_PAX",
            &CurrencyPair::BcptTusd => "BCPT_TUSD",
            &CurrencyPair::BcptUsdc => "BCPT_USDC",
            &CurrencyPair::BeamBnb => "BEAM_BNB",
            &CurrencyPair::BeamBtc => "BEAM_BTC",
            &CurrencyPair::BeamUsdt => "BEAM_USDT",
            &CurrencyPair::BgbpUsdc => "BGBP_USDC",
            &CurrencyPair::BlzBnb => "BLZ_BNB",
            &CurrencyPair::BlzBtc => "BLZ_BTC",
            &CurrencyPair::BlzEth => "BLZ_ETH",
            &CurrencyPair::BnbBtc => "BNB_BTC",
            &CurrencyPair::BnbBusd => "BNB_BUSD",
            &CurrencyPair::BnbEth => "BNB_ETH",
            &CurrencyPair::BnbNgn => "BNB_NGN",
            &CurrencyPair::BnbPax => "BNB_PAX",
            &CurrencyPair::BnbRub => "BNB_RUB",
            &CurrencyPair::BnbTry => "BNB_TRY",
            &CurrencyPair::BnbTusd => "BNB_TUSD",
            &CurrencyPair::BnbUsdc => "BNB_USDC",
            &CurrencyPair::BnbUsds => "BNB_USDS",
            &CurrencyPair::BnbUsdt => "BNB_USDT",
            &CurrencyPair::BntBtc => "BNT_BTC",
            &CurrencyPair::BntEth => "BNT_ETH",
            &CurrencyPair::BqxBtc => "BQX_BTC",
            &CurrencyPair::BqxEth => "BQX_ETH",
            &CurrencyPair::BrdBnb => "BRD_BNB",
            &CurrencyPair::BrdBtc => "BRD_BTC",
            &CurrencyPair::BrdEth => "BRD_ETH",
            &CurrencyPair::BtcbBtc => "BTCB_BTC",
            &CurrencyPair::BtcBusd => "BTC_BUSD",
            &CurrencyPair::BtcDgb => "BTC_DGB",
            &CurrencyPair::BtcFct => "BTC_FCT",
            &CurrencyPair::BtcFoam => "BTC_FOAM",
            &CurrencyPair::BtcGrin => "BTC_GRIN",
            &CurrencyPair::BtcLpt => "BTC_LPT",
            &CurrencyPair::BtcMaid => "BTC_MAID",
            &CurrencyPair::BtcNgn => "BTC_NGN",
            &CurrencyPair::BtcNmr => "BTC_NMR",
            &CurrencyPair::BtcNxt => "BTC_NXT",
            &CurrencyPair::BtcOmni => "BTC_OMNI",
            &CurrencyPair::BtcPax => "BTC_PAX",
            &CurrencyPair::BtcRub => "BTC_RUB",
            &CurrencyPair::BtcStr => "BTC_STR",
            &CurrencyPair::BtcTry => "BTC_TRY",
            &CurrencyPair::BtcTusd => "BTC_TUSD",
            &CurrencyPair::BtcUsdc => "BTC_USDC",
            &CurrencyPair::BtcUsds => "BTC_USDS",
            &CurrencyPair::BtcUsdt => "BTC_USDT",
            &CurrencyPair::BtcVtc => "BTC_VTC",
            &CurrencyPair::BtcXpm => "BTC_XPM",
            &CurrencyPair::BtgBtc => "BTG_BTC",
            &CurrencyPair::BtgEth => "BTG_ETH",
            &CurrencyPair::BtsBnb => "BTS_BNB",
            &CurrencyPair::BtsBtc => "BTS_BTC",
            &CurrencyPair::BtsEth => "BTS_ETH",
            &CurrencyPair::BttBnb => "BTT_BNB",
            &CurrencyPair::BttBtc => "BTT_BTC",
            &CurrencyPair::BttPax => "BTT_PAX",
            &CurrencyPair::BttTrx => "BTT_TRX",
            &CurrencyPair::BttTusd => "BTT_TUSD",
            &CurrencyPair::BttUsdc => "BTT_USDC",
            &CurrencyPair::BttUsdt => "BTT_USDT",
            &CurrencyPair::BusdNgn => "BUSD_NGN",
            &CurrencyPair::BusdRub => "BUSD_RUB",
            &CurrencyPair::BusdTry => "BUSD_TRY",
            &CurrencyPair::BusdUsdt => "BUSD_USDT",
            &CurrencyPair::CdtBtc => "CDT_BTC",
            &CurrencyPair::CdtEth => "CDT_ETH",
            &CurrencyPair::CelrBnb => "CELR_BNB",
            &CurrencyPair::CelrBtc => "CELR_BTC",
            &CurrencyPair::CelrUsdt => "CELR_USDT",
            &CurrencyPair::ChatBtc => "CHAT_BTC",
            &CurrencyPair::ChatEth => "CHAT_ETH",
            &CurrencyPair::ChzBnb => "CHZ_BNB",
            &CurrencyPair::ChzBtc => "CHZ_BTC",
            &CurrencyPair::ChzUsdt => "CHZ_USDT",
            &CurrencyPair::CloakBtc => "CLOAK_BTC",
            &CurrencyPair::CloakEth => "CLOAK_ETH",
            &CurrencyPair::CmtBnb => "CMT_BNB",
            &CurrencyPair::CmtBtc => "CMT_BTC",
            &CurrencyPair::CmtEth => "CMT_ETH",
            &CurrencyPair::CndBnb => "CND_BNB",
            &CurrencyPair::CndBtc => "CND_BTC",
            &CurrencyPair::CndEth => "CND_ETH",
            &CurrencyPair::CocosBnb => "COCOS_BNB",
            &CurrencyPair::CocosBtc => "COCOS_BTC",
            &CurrencyPair::CocosUsdt => "COCOS_USDT",
            &CurrencyPair::CosBnb => "COS_BNB",
            &CurrencyPair::CosBtc => "COS_BTC",
            &CurrencyPair::CosUsdt => "COS_USDT",
            &CurrencyPair::CtxcBnb => "CTXC_BNB",
            &CurrencyPair::CtxcBtc => "CTXC_BTC",
            &CurrencyPair::CtxcUsdt => "CTXC_USDT",
            &CurrencyPair::CvcBnb => "CVC_BNB",
            &CurrencyPair::CvcBtc => "CVC_BTC",
            &CurrencyPair::CvcEth => "CVC_ETH",
            &CurrencyPair::CvcUsdt => "CVC_USDT",
            &CurrencyPair::DashBnb => "DASH_BNB",
            &CurrencyPair::DashBtc => "DASH_BTC",
            &CurrencyPair::DashEth => "DASH_ETH",
            &CurrencyPair::DashUsdt => "DASH_USDT",
            &CurrencyPair::DataBtc => "DATA_BTC",
            &CurrencyPair::DataEth => "DATA_ETH",
            &CurrencyPair::DcrBnb => "DCR_BNB",
            &CurrencyPair::DcrBtc => "DCR_BTC",
            &CurrencyPair::DentBtc => "DENT_BTC",
            &CurrencyPair::DentEth => "DENT_ETH",
            &CurrencyPair::DentUsdt => "DENT_USDT",
            &CurrencyPair::DgdBtc => "DGD_BTC",
            &CurrencyPair::DgdEth => "DGD_ETH",
            &CurrencyPair::DltBnb => "DLT_BNB",
            &CurrencyPair::DltBtc => "DLT_BTC",
            &CurrencyPair::DltEth => "DLT_ETH",
            &CurrencyPair::DntBtc => "DNT_BTC",
            &CurrencyPair::DntEth => "DNT_ETH",
            &CurrencyPair::DockBtc => "DOCK_BTC",
            &CurrencyPair::DockEth => "DOCK_ETH",
            &CurrencyPair::DockUsdt => "DOCK_USDT",
            &CurrencyPair::DogeBnb => "DOGE_BNB",
            &CurrencyPair::DogeBtc => "DOGE_BTC",
            &CurrencyPair::DogePax => "DOGE_PAX",
            &CurrencyPair::DogeUsdc => "DOGE_USDC",
            &CurrencyPair::DogeUsdt => "DOGE_USDT",
            &CurrencyPair::DuskBnb => "DUSK_BNB",
            &CurrencyPair::DuskBtc => "DUSK_BTC",
            &CurrencyPair::DuskPax => "DUSK_PAX",
            &CurrencyPair::DuskUsdc => "DUSK_USDC",
            &CurrencyPair::DuskUsdt => "DUSK_USDT",
            &CurrencyPair::EdoBtc => "EDO_BTC",
            &CurrencyPair::EdoEth => "EDO_ETH",
            &CurrencyPair::ElfBtc => "ELF_BTC",
            &CurrencyPair::ElfEth => "ELF_ETH",
            &CurrencyPair::EngBtc => "ENG_BTC",
            &CurrencyPair::EngEth => "ENG_ETH",
            &CurrencyPair::EnjBnb => "ENJ_BNB",
            &CurrencyPair::EnjBtc => "ENJ_BTC",
            &CurrencyPair::EnjEth => "ENJ_ETH",
            &CurrencyPair::EnjUsdt => "ENJ_USDT",
            &CurrencyPair::EosBnb => "EOS_BNB",
            &CurrencyPair::EosBtc => "EOS_BTC",
            &CurrencyPair::EosBusd => "EOS_BUSD",
            &CurrencyPair::EosEth => "EOS_ETH",
            &CurrencyPair::EosPax => "EOS_PAX",
            &CurrencyPair::EosTusd => "EOS_TUSD",
            &CurrencyPair::EosUsdc => "EOS_USDC",
            &CurrencyPair::EosUsdt => "EOS_USDT",
            &CurrencyPair::ErdBnb => "ERD_BNB",
            &CurrencyPair::ErdBtc => "ERD_BTC",
            &CurrencyPair::ErdPax => "ERD_PAX",
            &CurrencyPair::ErdUsdc => "ERD_USDC",
            &CurrencyPair::ErdUsdt => "ERD_USDT",
            &CurrencyPair::EtcBnb => "ETC_BNB",
            &CurrencyPair::EtcBtc => "ETC_BTC",
            &CurrencyPair::EtcBusd => "ETC_BUSD",
            &CurrencyPair::EtcEth => "ETC_ETH",
            &CurrencyPair::EtcPax => "ETC_PAX",
            &CurrencyPair::EtcTusd => "ETC_TUSD",
            &CurrencyPair::EtcUsdc => "ETC_USDC",
            &CurrencyPair::EtcUsdt => "ETC_USDT",
            &CurrencyPair::EthBtc => "ETH_BTC",
            &CurrencyPair::EthBusd => "ETH_BUSD",
            &CurrencyPair::EthPax => "ETH_PAX",
            &CurrencyPair::EthRub => "ETH_RUB",
            &CurrencyPair::EthTry => "ETH_TRY",
            &CurrencyPair::EthTusd => "ETH_TUSD",
            &CurrencyPair::EthUsdc => "ETH_USDC",
            &CurrencyPair::EthUsdt => "ETH_USDT",
            &CurrencyPair::EvxBtc => "EVX_BTC",
            &CurrencyPair::EvxEth => "EVX_ETH",
            &CurrencyPair::FetBnb => "FET_BNB",
            &CurrencyPair::FetBtc => "FET_BTC",
            &CurrencyPair::FetUsdt => "FET_USDT",
            &CurrencyPair::FtmBnb => "FTM_BNB",
            &CurrencyPair::FtmBtc => "FTM_BTC",
            &CurrencyPair::FtmPax => "FTM_PAX",
            &CurrencyPair::FtmTusd => "FTM_TUSD",
            &CurrencyPair::FtmUsdc => "FTM_USDC",
            &CurrencyPair::FtmUsdt => "FTM_USDT",
            &CurrencyPair::FttBnb => "FTT_BNB",
            &CurrencyPair::FttBtc => "FTT_BTC",
            &CurrencyPair::FttUsdt => "FTT_USDT",
            &CurrencyPair::FuelBtc => "FUEL_BTC",
            &CurrencyPair::FuelEth => "FUEL_ETH",
            &CurrencyPair::FunBtc => "FUN_BTC",
            &CurrencyPair::FunEth => "FUN_ETH",
            &CurrencyPair::FunUsdt => "FUN_USDT",
            &CurrencyPair::GasBtc => "GAS_BTC",
            &CurrencyPair::GntBnb => "GNT_BNB",
            &CurrencyPair::GntBtc => "GNT_BTC",
            &CurrencyPair::GntEth => "GNT_ETH",
            &CurrencyPair::GoBnb => "GO_BNB",
            &CurrencyPair::GoBtc => "GO_BTC",
            &CurrencyPair::GrsBtc => "GRS_BTC",
            &CurrencyPair::GrsEth => "GRS_ETH",
            &CurrencyPair::GtoBnb => "GTO_BNB",
            &CurrencyPair::GtoBtc => "GTO_BTC",
            &CurrencyPair::GtoEth => "GTO_ETH",
            &CurrencyPair::GtoPax => "GTO_PAX",
            &CurrencyPair::GtoTusd => "GTO_TUSD",
            &CurrencyPair::GtoUsdc => "GTO_USDC",
            &CurrencyPair::GtoUsdt => "GTO_USDT",
            &CurrencyPair::GvtBtc => "GVT_BTC",
            &CurrencyPair::GvtEth => "GVT_ETH",
            &CurrencyPair::GxsBtc => "GXS_BTC",
            &CurrencyPair::GxsEth => "GXS_ETH",
            &CurrencyPair::HbarBnb => "HBAR_BNB",
            &CurrencyPair::HbarBtc => "HBAR_BTC",
            &CurrencyPair::HbarUsdt => "HBAR_USDT",
            &CurrencyPair::HcBtc => "HC_BTC",
            &CurrencyPair::HcEth => "HC_ETH",
            &CurrencyPair::HcUsdt => "HC_USDT",
            &CurrencyPair::HotBnb => "HOT_BNB",
            &CurrencyPair::HotBtc => "HOT_BTC",
            &CurrencyPair::HotEth => "HOT_ETH",
            &CurrencyPair::HotUsdt => "HOT_USDT",
            &CurrencyPair::HsrBtc => "HSR_BTC",
            &CurrencyPair::HsrEth => "HSR_ETH",
            &CurrencyPair::IcnBtc => "ICN_BTC",
            &CurrencyPair::IcnEth => "ICN_ETH",
            &CurrencyPair::IcxBnb => "ICX_BNB",
            &CurrencyPair::IcxBtc => "ICX_BTC",
            &CurrencyPair::IcxEth => "ICX_ETH",
            &CurrencyPair::IcxUsdt => "ICX_USDT",
            &CurrencyPair::InsBtc => "INS_BTC",
            &CurrencyPair::InsEth => "INS_ETH",
            &CurrencyPair::IostBnb => "IOST_BNB",
            &CurrencyPair::IostBtc => "IOST_BTC",
            &CurrencyPair::IostEth => "IOST_ETH",
            &CurrencyPair::IostUsdt => "IOST_USDT",
            &CurrencyPair::IotaBnb => "IOTA_BNB",
            &CurrencyPair::IotaBtc => "IOTA_BTC",
            &CurrencyPair::IotaEth => "IOTA_ETH",
            &CurrencyPair::IotaUsdt => "IOTA_USDT",
            &CurrencyPair::IotxBtc => "IOTX_BTC",
            &CurrencyPair::IotxEth => "IOTX_ETH",
            &CurrencyPair::IotxUsdt => "IOTX_USDT",
            &CurrencyPair::KavaBnb => "KAVA_BNB",
            &CurrencyPair::KavaBtc => "KAVA_BTC",
            &CurrencyPair::KavaUsdt => "KAVA_USDT",
            &CurrencyPair::KeyBtc => "KEY_BTC",
            &CurrencyPair::KeyEth => "KEY_ETH",
            &CurrencyPair::KeyUsdt => "KEY_USDT",
            &CurrencyPair::KmdBtc => "KMD_BTC",
            &CurrencyPair::KmdEth => "KMD_ETH",
            &CurrencyPair::KncBtc => "KNC_BTC",
            &CurrencyPair::KncEth => "KNC_ETH",
            &CurrencyPair::LendBtc => "LEND_BTC",
            &CurrencyPair::LendEth => "LEND_ETH",
            &CurrencyPair::LinkBtc => "LINK_BTC",
            &CurrencyPair::LinkBusd => "LINK_BUSD",
            &CurrencyPair::LinkEth => "LINK_ETH",
            &CurrencyPair::LinkPax => "LINK_PAX",
            &CurrencyPair::LinkTusd => "LINK_TUSD",
            &CurrencyPair::LinkUsdc => "LINK_USDC",
            &CurrencyPair::LinkUsdt => "LINK_USDT",
            &CurrencyPair::LoomBnb => "LOOM_BNB",
            &CurrencyPair::LoomBtc => "LOOM_BTC",
            &CurrencyPair::LoomEth => "LOOM_ETH",
            &CurrencyPair::LrcBtc => "LRC_BTC",
            &CurrencyPair::LrcEth => "LRC_ETH",
            &CurrencyPair::LskBnb => "LSK_BNB",
            &CurrencyPair::LskBtc => "LSK_BTC",
            &CurrencyPair::LskEth => "LSK_ETH",
            &CurrencyPair::LtcBnb => "LTC_BNB",
            &CurrencyPair::LtcBtc => "LTC_BTC",
            &CurrencyPair::LtcBusd => "LTC_BUSD",
            &CurrencyPair::LtcEth => "LTC_ETH",
            &CurrencyPair::LtcPax => "LTC_PAX",
            &CurrencyPair::LtcTusd => "LTC_TUSD",
            &CurrencyPair::LtcUsdc => "LTC_USDC",
            &CurrencyPair::LtcUsdt => "LTC_USDT",
            &CurrencyPair::LunBtc => "LUN_BTC",
            &CurrencyPair::LunEth => "LUN_ETH",
            &CurrencyPair::ManaBtc => "MANA_BTC",
            &CurrencyPair::ManaEth => "MANA_ETH",
            &CurrencyPair::MaticBnb => "MATIC_BNB",
            &CurrencyPair::MaticBtc => "MATIC_BTC",
            &CurrencyPair::MaticUsdt => "MATIC_USDT",
            &CurrencyPair::McoBnb => "MCO_BNB",
            &CurrencyPair::McoBtc => "MCO_BTC",
            &CurrencyPair::McoEth => "MCO_ETH",
            &CurrencyPair::McoUsdt => "MCO_USDT",
            &CurrencyPair::MdaBtc => "MDA_BTC",
            &CurrencyPair::MdaEth => "MDA_ETH",
            &CurrencyPair::MftBnb => "MFT_BNB",
            &CurrencyPair::MftBtc => "MFT_BTC",
            &CurrencyPair::MftEth => "MFT_ETH",
            &CurrencyPair::MftUsdt => "MFT_USDT",
            &CurrencyPair::MithBnb => "MITH_BNB",
            &CurrencyPair::MithBtc => "MITH_BTC",
            &CurrencyPair::MithUsdt => "MITH_USDT",
            &CurrencyPair::ModBtc => "MOD_BTC",
            &CurrencyPair::ModEth => "MOD_ETH",
            &CurrencyPair::MthBtc => "MTH_BTC",
            &CurrencyPair::MthEth => "MTH_ETH",
            &CurrencyPair::MtlBtc => "MTL_BTC",
            &CurrencyPair::MtlEth => "MTL_ETH",
            &CurrencyPair::MtlUsdt => "MTL_USDT",
            &CurrencyPair::NanoBnb => "NANO_BNB",
            &CurrencyPair::NanoBtc => "NANO_BTC",
            &CurrencyPair::NanoEth => "NANO_ETH",
            &CurrencyPair::NanoUsdt => "NANO_USDT",
            &CurrencyPair::NasBnb => "NAS_BNB",
            &CurrencyPair::NasBtc => "NAS_BTC",
            &CurrencyPair::NasEth => "NAS_ETH",
            &CurrencyPair::NavBnb => "NAV_BNB",
            &CurrencyPair::NavBtc => "NAV_BTC",
            &CurrencyPair::NavEth => "NAV_ETH",
            &CurrencyPair::NcashBnb => "NCASH_BNB",
            &CurrencyPair::NcashBtc => "NCASH_BTC",
            &CurrencyPair::NcashEth => "NCASH_ETH",
            &CurrencyPair::NeblBnb => "NEBL_BNB",
            &CurrencyPair::NeblBtc => "NEBL_BTC",
            &CurrencyPair::NeblEth => "NEBL_ETH",
            &CurrencyPair::NeoBnb => "NEO_BNB",
            &CurrencyPair::NeoBtc => "NEO_BTC",
            &CurrencyPair::NeoEth => "NEO_ETH",
            &CurrencyPair::NeoPax => "NEO_PAX",
            &CurrencyPair::NeoTusd => "NEO_TUSD",
            &CurrencyPair::NeoUsdc => "NEO_USDC",
            &CurrencyPair::NeoUsdt => "NEO_USDT",
            &CurrencyPair::NknBnb => "NKN_BNB",
            &CurrencyPair::NknBtc => "NKN_BTC",
            &CurrencyPair::NknUsdt => "NKN_USDT",
            &CurrencyPair::NpxsBtc => "NPXS_BTC",
            &CurrencyPair::NpxsEth => "NPXS_ETH",
            &CurrencyPair::NpxsUsdc => "NPXS_USDC",
            &CurrencyPair::NpxsUsdt => "NPXS_USDT",
            &CurrencyPair::NulsBnb => "NULS_BNB",
            &CurrencyPair::NulsBtc => "NULS_BTC",
            &CurrencyPair::NulsEth => "NULS_ETH",
            &CurrencyPair::NulsUsdt => "NULS_USDT",
            &CurrencyPair::NxsBnb => "NXS_BNB",
            &CurrencyPair::NxsBtc => "NXS_BTC",
            &CurrencyPair::NxsEth => "NXS_ETH",
            &CurrencyPair::OaxBtc => "OAX_BTC",
            &CurrencyPair::OaxEth => "OAX_ETH",
            &CurrencyPair::OmgBnb => "OMG_BNB",
            &CurrencyPair::OmgBtc => "OMG_BTC",
            &CurrencyPair::OmgEth => "OMG_ETH",
            &CurrencyPair::OmgUsdt => "OMG_USDT",
            &CurrencyPair::OneBnb => "ONE_BNB",
            &CurrencyPair::OneBtc => "ONE_BTC",
            &CurrencyPair::OnePax => "ONE_PAX",
            &CurrencyPair::OneTusd => "ONE_TUSD",
            &CurrencyPair::OneUsdc => "ONE_USDC",
            &CurrencyPair::OneUsdt => "ONE_USDT",
            &CurrencyPair::OngBnb => "ONG_BNB",
            &CurrencyPair::OngBtc => "ONG_BTC",
            &CurrencyPair::OngUsdt => "ONG_USDT",
            &CurrencyPair::OntBnb => "ONT_BNB",
            &CurrencyPair::OntBtc => "ONT_BTC",
            &CurrencyPair::OntEth => "ONT_ETH",
            &CurrencyPair::OntPax => "ONT_PAX",
            &CurrencyPair::OntUsdc => "ONT_USDC",
            &CurrencyPair::OntUsdt => "ONT_USDT",
            &CurrencyPair::OstBnb => "OST_BNB",
            &CurrencyPair::OstBtc => "OST_BTC",
            &CurrencyPair::OstEth => "OST_ETH",
            &CurrencyPair::PaxBnb => "PAX_BNB",
            &CurrencyPair::PaxBtc => "PAX_BTC",
            &CurrencyPair::PaxEth => "PAX_ETH",
            &CurrencyPair::PaxTusd => "PAX_TUSD",
            &CurrencyPair::PaxUsdt => "PAX_USDT",
            &CurrencyPair::PerlBnb => "PERL_BNB",
            &CurrencyPair::PerlBtc => "PERL_BTC",
            &CurrencyPair::PerlUsdc => "PERL_USDC",
            &CurrencyPair::PerlUsdt => "PERL_USDT",
            &CurrencyPair::PhbBnb => "PHB_BNB",
            &CurrencyPair::PhbBtc => "PHB_BTC",
            &CurrencyPair::PhbPax => "PHB_PAX",
            &CurrencyPair::PhbTusd => "PHB_TUSD",
            &CurrencyPair::PhbUsdc => "PHB_USDC",
            &CurrencyPair::PhxBnb => "PHX_BNB",
            &CurrencyPair::PhxBtc => "PHX_BTC",
            &CurrencyPair::PhxEth => "PHX_ETH",
            &CurrencyPair::PivxBnb => "PIVX_BNB",
            &CurrencyPair::PivxBtc => "PIVX_BTC",
            &CurrencyPair::PivxEth => "PIVX_ETH",
            &CurrencyPair::PoaBnb => "POA_BNB",
            &CurrencyPair::PoaBtc => "POA_BTC",
            &CurrencyPair::PoaEth => "POA_ETH",
            &CurrencyPair::PoeBtc => "POE_BTC",
            &CurrencyPair::PoeEth => "POE_ETH",
            &CurrencyPair::PolyBnb => "POLY_BNB",
            &CurrencyPair::PolyBtc => "POLY_BTC",
            &CurrencyPair::PowrBnb => "POWR_BNB",
            &CurrencyPair::PowrBtc => "POWR_BTC",
            &CurrencyPair::PowrEth => "POWR_ETH",
            &CurrencyPair::PptBtc => "PPT_BTC",
            &CurrencyPair::PptEth => "PPT_ETH",
            &CurrencyPair::QkcBtc => "QKC_BTC",
            &CurrencyPair::QkcEth => "QKC_ETH",
            &CurrencyPair::QlcBnb => "QLC_BNB",
            &CurrencyPair::QlcBtc => "QLC_BTC",
            &CurrencyPair::QlcEth => "QLC_ETH",
            &CurrencyPair::QspBnb => "QSP_BNB",
            &CurrencyPair::QspBtc => "QSP_BTC",
            &CurrencyPair::QspEth => "QSP_ETH",
            &CurrencyPair::QtumBnb => "QTUM_BNB",
            &CurrencyPair::QtumBtc => "QTUM_BTC",
            &CurrencyPair::QtumBusd => "QTUM_BUSD",
            &CurrencyPair::QtumEth => "QTUM_ETH",
            &CurrencyPair::QtumUsdt => "QTUM_USDT",
            &CurrencyPair::RcnBnb => "RCN_BNB",
            &CurrencyPair::RcnBtc => "RCN_BTC",
            &CurrencyPair::RcnEth => "RCN_ETH",
            &CurrencyPair::RdnBnb => "RDN_BNB",
            &CurrencyPair::RdnBtc => "RDN_BTC",
            &CurrencyPair::RdnEth => "RDN_ETH",
            &CurrencyPair::RenBnb => "REN_BNB",
            &CurrencyPair::RenBtc => "REN_BTC",
            &CurrencyPair::RenUsdt => "REN_USDT",
            &CurrencyPair::RepBnb => "REP_BNB",
            &CurrencyPair::RepBtc => "REP_BTC",
            &CurrencyPair::RepEth => "REP_ETH",
            &CurrencyPair::ReqBtc => "REQ_BTC",
            &CurrencyPair::ReqEth => "REQ_ETH",
            &CurrencyPair::RlcBnb => "RLC_BNB",
            &CurrencyPair::RlcBtc => "RLC_BTC",
            &CurrencyPair::RlcEth => "RLC_ETH",
            &CurrencyPair::RlcUsdt => "RLC_USDT",
            &CurrencyPair::RpxBnb => "RPX_BNB",
            &CurrencyPair::RpxBtc => "RPX_BTC",
            &CurrencyPair::RpxEth => "RPX_ETH",
            &CurrencyPair::RvnBnb => "RVN_BNB",
            &CurrencyPair::RvnBtc => "RVN_BTC",
            &CurrencyPair::RvnUsdt => "RVN_USDT",
            &CurrencyPair::SaltBtc => "SALT_BTC",
            &CurrencyPair::SaltEth => "SALT_ETH",
            &CurrencyPair::ScBnb => "SC_BNB",
            &CurrencyPair::ScBtc => "SC_BTC",
            &CurrencyPair::ScEth => "SC_ETH",
            &CurrencyPair::SkyBnb => "SKY_BNB",
            &CurrencyPair::SkyBtc => "SKY_BTC",
            &CurrencyPair::SkyEth => "SKY_ETH",
            &CurrencyPair::SnglsBtc => "SNGLS_BTC",
            &CurrencyPair::SnglsEth => "SNGLS_ETH",
            &CurrencyPair::SnmBtc => "SNM_BTC",
            &CurrencyPair::SnmEth => "SNM_ETH",
            &CurrencyPair::SntBtc => "SNT_BTC",
            &CurrencyPair::SntEth => "SNT_ETH",
            &CurrencyPair::SteemBnb => "STEEM_BNB",
            &CurrencyPair::SteemBtc => "STEEM_BTC",
            &CurrencyPair::SteemEth => "STEEM_ETH",
            &CurrencyPair::StorjBtc => "STORJ_BTC",
            &CurrencyPair::StorjEth => "STORJ_ETH",
            &CurrencyPair::StormBnb => "STORM_BNB",
            &CurrencyPair::StormBtc => "STORM_BTC",
            &CurrencyPair::StormEth => "STORM_ETH",
            &CurrencyPair::StormUsdt => "STORM_USDT",
            &CurrencyPair::StratBtc => "STRAT_BTC",
            &CurrencyPair::StratEth => "STRAT_ETH",
            &CurrencyPair::StxBnb => "STX_BNB",
            &CurrencyPair::StxBtc => "STX_BTC",
            &CurrencyPair::StxUsdt => "STX_USDT",
            &CurrencyPair::SubBtc => "SUB_BTC",
            &CurrencyPair::SubEth => "SUB_ETH",
            &CurrencyPair::SysBnb => "SYS_BNB",
            &CurrencyPair::SysBtc => "SYS_BTC",
            &CurrencyPair::SysEth => "SYS_ETH",
            &CurrencyPair::TfuelBnb => "TFUEL_BNB",
            &CurrencyPair::TfuelBtc => "TFUEL_BTC",
            &CurrencyPair::TfuelPax => "TFUEL_PAX",
            &CurrencyPair::TfuelTusd => "TFUEL_TUSD",
            &CurrencyPair::TfuelUsdc => "TFUEL_USDC",
            &CurrencyPair::TfuelUsdt => "TFUEL_USDT",
            &CurrencyPair::ThetaBnb => "THETA_BNB",
            &CurrencyPair::ThetaBtc => "THETA_BTC",
            &CurrencyPair::ThetaEth => "THETA_ETH",
            &CurrencyPair::ThetaUsdt => "THETA_USDT",
            &CurrencyPair::TnbBtc => "TNB_BTC",
            &CurrencyPair::TnbEth => "TNB_ETH",
            &CurrencyPair::TntBtc => "TNT_BTC",
            &CurrencyPair::TntEth => "TNT_ETH",
            &CurrencyPair::TomoBnb => "TOMO_BNB",
            &CurrencyPair::TomoBtc => "TOMO_BTC",
            &CurrencyPair::TomoUsdc => "TOMO_USDC",
            &CurrencyPair::TomoUsdt => "TOMO_USDT",
            &CurrencyPair::TrigBnb => "TRIG_BNB",
            &CurrencyPair::TrigBtc => "TRIG_BTC",
            &CurrencyPair::TrigEth => "TRIG_ETH",
            &CurrencyPair::TroyBnb => "TROY_BNB",
            &CurrencyPair::TroyBtc => "TROY_BTC",
            &CurrencyPair::TroyUsdt => "TROY_USDT",
            &CurrencyPair::TrxBnb => "TRX_BNB",
            &CurrencyPair::TrxBtc => "TRX_BTC",
            &CurrencyPair::TrxBusd => "TRX_BUSD",
            &CurrencyPair::TrxEth => "TRX_ETH",
            &CurrencyPair::TrxPax => "TRX_PAX",
            &CurrencyPair::TrxTusd => "TRX_TUSD",
            &CurrencyPair::TrxUsdc => "TRX_USDC",
            &CurrencyPair::TrxUsdt => "TRX_USDT",
            &CurrencyPair::TrxXrp => "TRX_XRP",
            &CurrencyPair::TusdbTusd => "TUSDB_TUSD",
            &CurrencyPair::TusdBnb => "TUSD_BNB",
            &CurrencyPair::TusdBtc => "TUSD_BTC",
            &CurrencyPair::TusdEth => "TUSD_ETH",
            &CurrencyPair::TusdUsdt => "TUSD_USDT",
            &CurrencyPair::UsdcBnb => "USDC_BNB",
            &CurrencyPair::UsdcDash => "USDC_DASH",
            &CurrencyPair::UsdcGrin => "USDC_GRIN",
            &CurrencyPair::UsdcPax => "USDC_PAX",
            &CurrencyPair::UsdcStr => "USDC_STR",
            &CurrencyPair::UsdcTusd => "USDC_TUSD",
            &CurrencyPair::UsdcUsdt => "USDC_USDT",
            &CurrencyPair::UsdcXmr => "USDC_XMR",
            &CurrencyPair::UsdsbUsds => "USDSB_USDS",
            &CurrencyPair::UsdsbUsdt => "USDSB_USDT",
            &CurrencyPair::UsdsPax => "USDS_PAX",
            &CurrencyPair::UsdsTusd => "USDS_TUSD",
            &CurrencyPair::UsdsUsdc => "USDS_USDC",
            &CurrencyPair::UsdsUsdt => "USDS_USDT",
            &CurrencyPair::UsdtDgb => "USDT_DGB",
            &CurrencyPair::UsdtGnt => "USDT_GNT",
            &CurrencyPair::UsdtGrin => "USDT_GRIN",
            &CurrencyPair::UsdtLsk => "USDT_LSK",
            &CurrencyPair::UsdtMana => "USDT_MANA",
            &CurrencyPair::UsdtNxt => "USDT_NXT",
            &CurrencyPair::UsdtRep => "USDT_REP",
            &CurrencyPair::UsdtRub => "USDT_RUB",
            &CurrencyPair::UsdtSc => "USDT_SC",
            &CurrencyPair::UsdtStr => "USDT_STR",
            &CurrencyPair::UsdtTry => "USDT_TRY",
            &CurrencyPair::VenBnb => "VEN_BNB",
            &CurrencyPair::VenBtc => "VEN_BTC",
            &CurrencyPair::VenEth => "VEN_ETH",
            &CurrencyPair::VenUsdt => "VEN_USDT",
            &CurrencyPair::VetBnb => "VET_BNB",
            &CurrencyPair::VetBtc => "VET_BTC",
            &CurrencyPair::VetBusd => "VET_BUSD",
            &CurrencyPair::VetEth => "VET_ETH",
            &CurrencyPair::VetUsdt => "VET_USDT",
            &CurrencyPair::ViaBnb => "VIA_BNB",
            &CurrencyPair::ViaBtc => "VIA_BTC",
            &CurrencyPair::ViaEth => "VIA_ETH",
            &CurrencyPair::VibeBtc => "VIBE_BTC",
            &CurrencyPair::VibeEth => "VIBE_ETH",
            &CurrencyPair::VibBtc => "VIB_BTC",
            &CurrencyPair::VibEth => "VIB_ETH",
            &CurrencyPair::ViteBnb => "VITE_BNB",
            &CurrencyPair::ViteBtc => "VITE_BTC",
            &CurrencyPair::ViteUsdt => "VITE_USDT",
            &CurrencyPair::WabiBnb => "WABI_BNB",
            &CurrencyPair::WabiBtc => "WABI_BTC",
            &CurrencyPair::WabiEth => "WABI_ETH",
            &CurrencyPair::WanBnb => "WAN_BNB",
            &CurrencyPair::WanBtc => "WAN_BTC",
            &CurrencyPair::WanEth => "WAN_ETH",
            &CurrencyPair::WanUsdt => "WAN_USDT",
            &CurrencyPair::WavesBnb => "WAVES_BNB",
            &CurrencyPair::WavesBtc => "WAVES_BTC",
            &CurrencyPair::WavesEth => "WAVES_ETH",
            &CurrencyPair::WavesPax => "WAVES_PAX",
            &CurrencyPair::WavesTusd => "WAVES_TUSD",
            &CurrencyPair::WavesUsdc => "WAVES_USDC",
            &CurrencyPair::WavesUsdt => "WAVES_USDT",
            &CurrencyPair::WingsBtc => "WINGS_BTC",
            &CurrencyPair::WingsEth => "WINGS_ETH",
            &CurrencyPair::WinBnb => "WIN_BNB",
            &CurrencyPair::WinBtc => "WIN_BTC",
            &CurrencyPair::WinTrx => "WIN_TRX",
            &CurrencyPair::WinUsdc => "WIN_USDC",
            &CurrencyPair::WinUsdt => "WIN_USDT",
            &CurrencyPair::WprBtc => "WPR_BTC",
            &CurrencyPair::WprEth => "WPR_ETH",
            &CurrencyPair::WtcBnb => "WTC_BNB",
            &CurrencyPair::WtcBtc => "WTC_BTC",
            &CurrencyPair::WtcEth => "WTC_ETH",
            &CurrencyPair::XemBnb => "XEM_BNB",
            &CurrencyPair::XemBtc => "XEM_BTC",
            &CurrencyPair::XemEth => "XEM_ETH",
            &CurrencyPair::XlmBnb => "XLM_BNB",
            &CurrencyPair::XlmBtc => "XLM_BTC",
            &CurrencyPair::XlmBusd => "XLM_BUSD",
            &CurrencyPair::XlmEth => "XLM_ETH",
            &CurrencyPair::XlmPax => "XLM_PAX",
            &CurrencyPair::XlmTusd => "XLM_TUSD",
            &CurrencyPair::XlmUsdc => "XLM_USDC",
            &CurrencyPair::XlmUsdt => "XLM_USDT",
            &CurrencyPair::XmrBnb => "XMR_BNB",
            &CurrencyPair::XmrBtc => "XMR_BTC",
            &CurrencyPair::XmrEth => "XMR_ETH",
            &CurrencyPair::XmrUsdt => "XMR_USDT",
            &CurrencyPair::XrpBnb => "XRP_BNB",
            &CurrencyPair::XrpBtc => "XRP_BTC",
            &CurrencyPair::XrpBusd => "XRP_BUSD",
            &CurrencyPair::XrpEth => "XRP_ETH",
            &CurrencyPair::XrpPax => "XRP_PAX",
            &CurrencyPair::XrpRub => "XRP_RUB",
            &CurrencyPair::XrpTry => "XRP_TRY",
            &CurrencyPair::XrpTusd => "XRP_TUSD",
            &CurrencyPair::XrpUsdc => "XRP_USDC",
            &CurrencyPair::XrpUsdt => "XRP_USDT",
            &CurrencyPair::XtzBnb => "XTZ_BNB",
            &CurrencyPair::XtzBtc => "XTZ_BTC",
            &CurrencyPair::XtzUsdt => "XTZ_USDT",
            &CurrencyPair::XvgBtc => "XVG_BTC",
            &CurrencyPair::XvgEth => "XVG_ETH",
            &CurrencyPair::XzcBnb => "XZC_BNB",
            &CurrencyPair::XzcBtc => "XZC_BTC",
            &CurrencyPair::XzcEth => "XZC_ETH",
            &CurrencyPair::XzcXrp => "XZC_XRP",
            &CurrencyPair::YoyoBnb => "YOYO_BNB",
            &CurrencyPair::YoyoBtc => "YOYO_BTC",
            &CurrencyPair::YoyoEth => "YOYO_ETH",
            &CurrencyPair::ZecBnb => "ZEC_BNB",
            &CurrencyPair::ZecBtc => "ZEC_BTC",
            &CurrencyPair::ZecEth => "ZEC_ETH",
            &CurrencyPair::ZecPax => "ZEC_PAX",
            &CurrencyPair::ZecTusd => "ZEC_TUSD",
            &CurrencyPair::ZecUsdc => "ZEC_USDC",
            &CurrencyPair::ZecUsdt => "ZEC_USDT",
            &CurrencyPair::ZenBnb => "ZEN_BNB",
            &CurrencyPair::ZenBtc => "ZEN_BTC",
            &CurrencyPair::ZenEth => "ZEN_ETH",
            &CurrencyPair::ZilBnb => "ZIL_BNB",
            &CurrencyPair::ZilBtc => "ZIL_BTC",
            &CurrencyPair::ZilEth => "ZIL_ETH",
            &CurrencyPair::ZilUsdt => "ZIL_USDT",
            &CurrencyPair::ZrxBnb => "ZRX_BNB",
            &CurrencyPair::ZrxBtc => "ZRX_BTC",
            &CurrencyPair::ZrxEth => "ZRX_ETH",
            &CurrencyPair::ZrxUsdt => "ZRX_USDT",
        }
    }

    pub fn quote(&self) -> Currency {
        match self {
            CurrencyPair::Custom(_, ref quote, _) => quote.clone(),
            &CurrencyPair::AdaBnb => Currency::Ada,
            &CurrencyPair::AdaBtc => Currency::Ada,
            &CurrencyPair::AdaBusd => Currency::Ada,
            &CurrencyPair::AdaEth => Currency::Ada,
            &CurrencyPair::AdaPax => Currency::Ada,
            &CurrencyPair::AdaTusd => Currency::Ada,
            &CurrencyPair::AdaUsdc => Currency::Ada,
            &CurrencyPair::AdaUsdt => Currency::Ada,
            &CurrencyPair::AdxBnb => Currency::Adx,
            &CurrencyPair::AdxBtc => Currency::Adx,
            &CurrencyPair::AdxEth => Currency::Adx,
            &CurrencyPair::AeBnb => Currency::Ae,
            &CurrencyPair::AeBtc => Currency::Ae,
            &CurrencyPair::AeEth => Currency::Ae,
            &CurrencyPair::AgiBnb => Currency::Agi,
            &CurrencyPair::AgiBtc => Currency::Agi,
            &CurrencyPair::AgiEth => Currency::Agi,
            &CurrencyPair::AionBnb => Currency::Aion,
            &CurrencyPair::AionBtc => Currency::Aion,
            &CurrencyPair::AionEth => Currency::Aion,
            &CurrencyPair::AlgoBnb => Currency::Algo,
            &CurrencyPair::AlgoBtc => Currency::Algo,
            &CurrencyPair::AlgoPax => Currency::Algo,
            &CurrencyPair::AlgoTusd => Currency::Algo,
            &CurrencyPair::AlgoUsdc => Currency::Algo,
            &CurrencyPair::AlgoUsdt => Currency::Algo,
            &CurrencyPair::AmbBnb => Currency::Amb,
            &CurrencyPair::AmbBtc => Currency::Amb,
            &CurrencyPair::AmbEth => Currency::Amb,
            &CurrencyPair::AnkrBnb => Currency::Ankr,
            &CurrencyPair::AnkrBtc => Currency::Ankr,
            &CurrencyPair::AnkrPax => Currency::Ankr,
            &CurrencyPair::AnkrTusd => Currency::Ankr,
            &CurrencyPair::AnkrUsdc => Currency::Ankr,
            &CurrencyPair::AnkrUsdt => Currency::Ankr,
            &CurrencyPair::AppcBnb => Currency::Appc,
            &CurrencyPair::AppcBtc => Currency::Appc,
            &CurrencyPair::AppcEth => Currency::Appc,
            &CurrencyPair::ArdrBnb => Currency::Ardr,
            &CurrencyPair::ArdrBtc => Currency::Ardr,
            &CurrencyPair::ArdrEth => Currency::Ardr,
            &CurrencyPair::ArkBtc => Currency::Ark,
            &CurrencyPair::ArkEth => Currency::Ark,
            &CurrencyPair::ArnBtc => Currency::Arn,
            &CurrencyPair::ArnEth => Currency::Arn,
            &CurrencyPair::ArpaBnb => Currency::Arpa,
            &CurrencyPair::ArpaBtc => Currency::Arpa,
            &CurrencyPair::ArpaUsdt => Currency::Arpa,
            &CurrencyPair::AstBtc => Currency::Ast,
            &CurrencyPair::AstEth => Currency::Ast,
            &CurrencyPair::AtomBnb => Currency::Atom,
            &CurrencyPair::AtomBtc => Currency::Atom,
            &CurrencyPair::AtomPax => Currency::Atom,
            &CurrencyPair::AtomTusd => Currency::Atom,
            &CurrencyPair::AtomUsdc => Currency::Atom,
            &CurrencyPair::AtomUsdt => Currency::Atom,
            &CurrencyPair::BandBnb => Currency::Band,
            &CurrencyPair::BandBtc => Currency::Band,
            &CurrencyPair::BandUsdt => Currency::Band,
            &CurrencyPair::BatBnb => Currency::Bat,
            &CurrencyPair::BatBtc => Currency::Bat,
            &CurrencyPair::BatEth => Currency::Bat,
            &CurrencyPair::BatPax => Currency::Bat,
            &CurrencyPair::BatTusd => Currency::Bat,
            &CurrencyPair::BatUsdc => Currency::Bat,
            &CurrencyPair::BatUsdt => Currency::Bat,
            &CurrencyPair::BccBnb => Currency::Bcc,
            &CurrencyPair::BccBtc => Currency::Bcc,
            &CurrencyPair::BccEth => Currency::Bcc,
            &CurrencyPair::BccUsdt => Currency::Bcc,
            &CurrencyPair::BcdBtc => Currency::Bcd,
            &CurrencyPair::BcdEth => Currency::Bcd,
            &CurrencyPair::BchabcBtc => Currency::Bchabc,
            &CurrencyPair::BchabcBusd => Currency::Bchabc,
            &CurrencyPair::BchabcPax => Currency::Bchabc,
            &CurrencyPair::BchabcTusd => Currency::Bchabc,
            &CurrencyPair::BchabcUsdc => Currency::Bchabc,
            &CurrencyPair::BchabcUsdt => Currency::Bchabc,
            &CurrencyPair::BchsvBtc => Currency::Bchsv,
            &CurrencyPair::BchsvPax => Currency::Bchsv,
            &CurrencyPair::BchsvTusd => Currency::Bchsv,
            &CurrencyPair::BchsvUsdc => Currency::Bchsv,
            &CurrencyPair::BchsvUsdt => Currency::Bchsv,
            &CurrencyPair::BchBnb => Currency::Bch,
            &CurrencyPair::BchBtc => Currency::Bch,
            &CurrencyPair::BchBusd => Currency::Bch,
            &CurrencyPair::BchPax => Currency::Bch,
            &CurrencyPair::BchTusd => Currency::Bch,
            &CurrencyPair::BchUsdc => Currency::Bch,
            &CurrencyPair::BchUsdt => Currency::Bch,
            &CurrencyPair::BcnBnb => Currency::Bcn,
            &CurrencyPair::BcnBtc => Currency::Bcn,
            &CurrencyPair::BcnEth => Currency::Bcn,
            &CurrencyPair::BcptBnb => Currency::Bcpt,
            &CurrencyPair::BcptBtc => Currency::Bcpt,
            &CurrencyPair::BcptEth => Currency::Bcpt,
            &CurrencyPair::BcptPax => Currency::Bcpt,
            &CurrencyPair::BcptTusd => Currency::Bcpt,
            &CurrencyPair::BcptUsdc => Currency::Bcpt,
            &CurrencyPair::BeamBnb => Currency::Beam,
            &CurrencyPair::BeamBtc => Currency::Beam,
            &CurrencyPair::BeamUsdt => Currency::Beam,
            &CurrencyPair::BgbpUsdc => Currency::Bgbp,
            &CurrencyPair::BlzBnb => Currency::Blz,
            &CurrencyPair::BlzBtc => Currency::Blz,
            &CurrencyPair::BlzEth => Currency::Blz,
            &CurrencyPair::BnbBtc => Currency::Bnb,
            &CurrencyPair::BnbBusd => Currency::Bnb,
            &CurrencyPair::BnbEth => Currency::Bnb,
            &CurrencyPair::BnbNgn => Currency::Bnb,
            &CurrencyPair::BnbPax => Currency::Bnb,
            &CurrencyPair::BnbRub => Currency::Bnb,
            &CurrencyPair::BnbTry => Currency::Bnb,
            &CurrencyPair::BnbTusd => Currency::Bnb,
            &CurrencyPair::BnbUsdc => Currency::Bnb,
            &CurrencyPair::BnbUsds => Currency::Bnb,
            &CurrencyPair::BnbUsdt => Currency::Bnb,
            &CurrencyPair::BntBtc => Currency::Bnt,
            &CurrencyPair::BntEth => Currency::Bnt,
            &CurrencyPair::BqxBtc => Currency::Bqx,
            &CurrencyPair::BqxEth => Currency::Bqx,
            &CurrencyPair::BrdBnb => Currency::Brd,
            &CurrencyPair::BrdBtc => Currency::Brd,
            &CurrencyPair::BrdEth => Currency::Brd,
            &CurrencyPair::BtcbBtc => Currency::Btcb,
            &CurrencyPair::BtcBusd => Currency::Btc,
            &CurrencyPair::BtcDgb => Currency::Btc,
            &CurrencyPair::BtcFct => Currency::Btc,
            &CurrencyPair::BtcFoam => Currency::Btc,
            &CurrencyPair::BtcGrin => Currency::Btc,
            &CurrencyPair::BtcLpt => Currency::Btc,
            &CurrencyPair::BtcMaid => Currency::Btc,
            &CurrencyPair::BtcNgn => Currency::Btc,
            &CurrencyPair::BtcNmr => Currency::Btc,
            &CurrencyPair::BtcNxt => Currency::Btc,
            &CurrencyPair::BtcOmni => Currency::Btc,
            &CurrencyPair::BtcPax => Currency::Btc,
            &CurrencyPair::BtcRub => Currency::Btc,
            &CurrencyPair::BtcStr => Currency::Btc,
            &CurrencyPair::BtcTry => Currency::Btc,
            &CurrencyPair::BtcTusd => Currency::Btc,
            &CurrencyPair::BtcUsdc => Currency::Btc,
            &CurrencyPair::BtcUsds => Currency::Btc,
            &CurrencyPair::BtcUsdt => Currency::Btc,
            &CurrencyPair::BtcVtc => Currency::Btc,
            &CurrencyPair::BtcXpm => Currency::Btc,
            &CurrencyPair::BtgBtc => Currency::Btg,
            &CurrencyPair::BtgEth => Currency::Btg,
            &CurrencyPair::BtsBnb => Currency::Bts,
            &CurrencyPair::BtsBtc => Currency::Bts,
            &CurrencyPair::BtsEth => Currency::Bts,
            &CurrencyPair::BttBnb => Currency::Btt,
            &CurrencyPair::BttBtc => Currency::Btt,
            &CurrencyPair::BttPax => Currency::Btt,
            &CurrencyPair::BttTrx => Currency::Btt,
            &CurrencyPair::BttTusd => Currency::Btt,
            &CurrencyPair::BttUsdc => Currency::Btt,
            &CurrencyPair::BttUsdt => Currency::Btt,
            &CurrencyPair::BusdNgn => Currency::Busd,
            &CurrencyPair::BusdRub => Currency::Busd,
            &CurrencyPair::BusdTry => Currency::Busd,
            &CurrencyPair::BusdUsdt => Currency::Busd,
            &CurrencyPair::CdtBtc => Currency::Cdt,
            &CurrencyPair::CdtEth => Currency::Cdt,
            &CurrencyPair::CelrBnb => Currency::Celr,
            &CurrencyPair::CelrBtc => Currency::Celr,
            &CurrencyPair::CelrUsdt => Currency::Celr,
            &CurrencyPair::ChatBtc => Currency::Chat,
            &CurrencyPair::ChatEth => Currency::Chat,
            &CurrencyPair::ChzBnb => Currency::Chz,
            &CurrencyPair::ChzBtc => Currency::Chz,
            &CurrencyPair::ChzUsdt => Currency::Chz,
            &CurrencyPair::CloakBtc => Currency::Cloak,
            &CurrencyPair::CloakEth => Currency::Cloak,
            &CurrencyPair::CmtBnb => Currency::Cmt,
            &CurrencyPair::CmtBtc => Currency::Cmt,
            &CurrencyPair::CmtEth => Currency::Cmt,
            &CurrencyPair::CndBnb => Currency::Cnd,
            &CurrencyPair::CndBtc => Currency::Cnd,
            &CurrencyPair::CndEth => Currency::Cnd,
            &CurrencyPair::CocosBnb => Currency::Cocos,
            &CurrencyPair::CocosBtc => Currency::Cocos,
            &CurrencyPair::CocosUsdt => Currency::Cocos,
            &CurrencyPair::CosBnb => Currency::Cos,
            &CurrencyPair::CosBtc => Currency::Cos,
            &CurrencyPair::CosUsdt => Currency::Cos,
            &CurrencyPair::CtxcBnb => Currency::Ctxc,
            &CurrencyPair::CtxcBtc => Currency::Ctxc,
            &CurrencyPair::CtxcUsdt => Currency::Ctxc,
            &CurrencyPair::CvcBnb => Currency::Cvc,
            &CurrencyPair::CvcBtc => Currency::Cvc,
            &CurrencyPair::CvcEth => Currency::Cvc,
            &CurrencyPair::CvcUsdt => Currency::Cvc,
            &CurrencyPair::DashBnb => Currency::Dash,
            &CurrencyPair::DashBtc => Currency::Dash,
            &CurrencyPair::DashEth => Currency::Dash,
            &CurrencyPair::DashUsdt => Currency::Dash,
            &CurrencyPair::DataBtc => Currency::Data,
            &CurrencyPair::DataEth => Currency::Data,
            &CurrencyPair::DcrBnb => Currency::Dcr,
            &CurrencyPair::DcrBtc => Currency::Dcr,
            &CurrencyPair::DentBtc => Currency::Dent,
            &CurrencyPair::DentEth => Currency::Dent,
            &CurrencyPair::DentUsdt => Currency::Dent,
            &CurrencyPair::DgdBtc => Currency::Dgd,
            &CurrencyPair::DgdEth => Currency::Dgd,
            &CurrencyPair::DltBnb => Currency::Dlt,
            &CurrencyPair::DltBtc => Currency::Dlt,
            &CurrencyPair::DltEth => Currency::Dlt,
            &CurrencyPair::DntBtc => Currency::Dnt,
            &CurrencyPair::DntEth => Currency::Dnt,
            &CurrencyPair::DockBtc => Currency::Dock,
            &CurrencyPair::DockEth => Currency::Dock,
            &CurrencyPair::DockUsdt => Currency::Dock,
            &CurrencyPair::DogeBnb => Currency::Doge,
            &CurrencyPair::DogeBtc => Currency::Doge,
            &CurrencyPair::DogePax => Currency::Doge,
            &CurrencyPair::DogeUsdc => Currency::Doge,
            &CurrencyPair::DogeUsdt => Currency::Doge,
            &CurrencyPair::DuskBnb => Currency::Dusk,
            &CurrencyPair::DuskBtc => Currency::Dusk,
            &CurrencyPair::DuskPax => Currency::Dusk,
            &CurrencyPair::DuskUsdc => Currency::Dusk,
            &CurrencyPair::DuskUsdt => Currency::Dusk,
            &CurrencyPair::EdoBtc => Currency::Edo,
            &CurrencyPair::EdoEth => Currency::Edo,
            &CurrencyPair::ElfBtc => Currency::Elf,
            &CurrencyPair::ElfEth => Currency::Elf,
            &CurrencyPair::EngBtc => Currency::Eng,
            &CurrencyPair::EngEth => Currency::Eng,
            &CurrencyPair::EnjBnb => Currency::Enj,
            &CurrencyPair::EnjBtc => Currency::Enj,
            &CurrencyPair::EnjEth => Currency::Enj,
            &CurrencyPair::EnjUsdt => Currency::Enj,
            &CurrencyPair::EosBnb => Currency::Eos,
            &CurrencyPair::EosBtc => Currency::Eos,
            &CurrencyPair::EosBusd => Currency::Eos,
            &CurrencyPair::EosEth => Currency::Eos,
            &CurrencyPair::EosPax => Currency::Eos,
            &CurrencyPair::EosTusd => Currency::Eos,
            &CurrencyPair::EosUsdc => Currency::Eos,
            &CurrencyPair::EosUsdt => Currency::Eos,
            &CurrencyPair::ErdBnb => Currency::Erd,
            &CurrencyPair::ErdBtc => Currency::Erd,
            &CurrencyPair::ErdPax => Currency::Erd,
            &CurrencyPair::ErdUsdc => Currency::Erd,
            &CurrencyPair::ErdUsdt => Currency::Erd,
            &CurrencyPair::EtcBnb => Currency::Etc,
            &CurrencyPair::EtcBtc => Currency::Etc,
            &CurrencyPair::EtcBusd => Currency::Etc,
            &CurrencyPair::EtcEth => Currency::Etc,
            &CurrencyPair::EtcPax => Currency::Etc,
            &CurrencyPair::EtcTusd => Currency::Etc,
            &CurrencyPair::EtcUsdc => Currency::Etc,
            &CurrencyPair::EtcUsdt => Currency::Etc,
            &CurrencyPair::EthBtc => Currency::Eth,
            &CurrencyPair::EthBusd => Currency::Eth,
            &CurrencyPair::EthPax => Currency::Eth,
            &CurrencyPair::EthRub => Currency::Eth,
            &CurrencyPair::EthTry => Currency::Eth,
            &CurrencyPair::EthTusd => Currency::Eth,
            &CurrencyPair::EthUsdc => Currency::Eth,
            &CurrencyPair::EthUsdt => Currency::Eth,
            &CurrencyPair::EvxBtc => Currency::Evx,
            &CurrencyPair::EvxEth => Currency::Evx,
            &CurrencyPair::FetBnb => Currency::Fet,
            &CurrencyPair::FetBtc => Currency::Fet,
            &CurrencyPair::FetUsdt => Currency::Fet,
            &CurrencyPair::FtmBnb => Currency::Ftm,
            &CurrencyPair::FtmBtc => Currency::Ftm,
            &CurrencyPair::FtmPax => Currency::Ftm,
            &CurrencyPair::FtmTusd => Currency::Ftm,
            &CurrencyPair::FtmUsdc => Currency::Ftm,
            &CurrencyPair::FtmUsdt => Currency::Ftm,
            &CurrencyPair::FttBnb => Currency::Ftt,
            &CurrencyPair::FttBtc => Currency::Ftt,
            &CurrencyPair::FttUsdt => Currency::Ftt,
            &CurrencyPair::FuelBtc => Currency::Fuel,
            &CurrencyPair::FuelEth => Currency::Fuel,
            &CurrencyPair::FunBtc => Currency::Fun,
            &CurrencyPair::FunEth => Currency::Fun,
            &CurrencyPair::FunUsdt => Currency::Fun,
            &CurrencyPair::GasBtc => Currency::Gas,
            &CurrencyPair::GntBnb => Currency::Gnt,
            &CurrencyPair::GntBtc => Currency::Gnt,
            &CurrencyPair::GntEth => Currency::Gnt,
            &CurrencyPair::GoBnb => Currency::Go,
            &CurrencyPair::GoBtc => Currency::Go,
            &CurrencyPair::GrsBtc => Currency::Grs,
            &CurrencyPair::GrsEth => Currency::Grs,
            &CurrencyPair::GtoBnb => Currency::Gto,
            &CurrencyPair::GtoBtc => Currency::Gto,
            &CurrencyPair::GtoEth => Currency::Gto,
            &CurrencyPair::GtoPax => Currency::Gto,
            &CurrencyPair::GtoTusd => Currency::Gto,
            &CurrencyPair::GtoUsdc => Currency::Gto,
            &CurrencyPair::GtoUsdt => Currency::Gto,
            &CurrencyPair::GvtBtc => Currency::Gvt,
            &CurrencyPair::GvtEth => Currency::Gvt,
            &CurrencyPair::GxsBtc => Currency::Gxs,
            &CurrencyPair::GxsEth => Currency::Gxs,
            &CurrencyPair::HbarBnb => Currency::Hbar,
            &CurrencyPair::HbarBtc => Currency::Hbar,
            &CurrencyPair::HbarUsdt => Currency::Hbar,
            &CurrencyPair::HcBtc => Currency::Hc,
            &CurrencyPair::HcEth => Currency::Hc,
            &CurrencyPair::HcUsdt => Currency::Hc,
            &CurrencyPair::HotBnb => Currency::Hot,
            &CurrencyPair::HotBtc => Currency::Hot,
            &CurrencyPair::HotEth => Currency::Hot,
            &CurrencyPair::HotUsdt => Currency::Hot,
            &CurrencyPair::HsrBtc => Currency::Hsr,
            &CurrencyPair::HsrEth => Currency::Hsr,
            &CurrencyPair::IcnBtc => Currency::Icn,
            &CurrencyPair::IcnEth => Currency::Icn,
            &CurrencyPair::IcxBnb => Currency::Icx,
            &CurrencyPair::IcxBtc => Currency::Icx,
            &CurrencyPair::IcxEth => Currency::Icx,
            &CurrencyPair::IcxUsdt => Currency::Icx,
            &CurrencyPair::InsBtc => Currency::Ins,
            &CurrencyPair::InsEth => Currency::Ins,
            &CurrencyPair::IostBnb => Currency::Iost,
            &CurrencyPair::IostBtc => Currency::Iost,
            &CurrencyPair::IostEth => Currency::Iost,
            &CurrencyPair::IostUsdt => Currency::Iost,
            &CurrencyPair::IotaBnb => Currency::Iota,
            &CurrencyPair::IotaBtc => Currency::Iota,
            &CurrencyPair::IotaEth => Currency::Iota,
            &CurrencyPair::IotaUsdt => Currency::Iota,
            &CurrencyPair::IotxBtc => Currency::Iotx,
            &CurrencyPair::IotxEth => Currency::Iotx,
            &CurrencyPair::IotxUsdt => Currency::Iotx,
            &CurrencyPair::KavaBnb => Currency::Kava,
            &CurrencyPair::KavaBtc => Currency::Kava,
            &CurrencyPair::KavaUsdt => Currency::Kava,
            &CurrencyPair::KeyBtc => Currency::Key,
            &CurrencyPair::KeyEth => Currency::Key,
            &CurrencyPair::KeyUsdt => Currency::Key,
            &CurrencyPair::KmdBtc => Currency::Kmd,
            &CurrencyPair::KmdEth => Currency::Kmd,
            &CurrencyPair::KncBtc => Currency::Knc,
            &CurrencyPair::KncEth => Currency::Knc,
            &CurrencyPair::LendBtc => Currency::Lend,
            &CurrencyPair::LendEth => Currency::Lend,
            &CurrencyPair::LinkBtc => Currency::Link,
            &CurrencyPair::LinkBusd => Currency::Link,
            &CurrencyPair::LinkEth => Currency::Link,
            &CurrencyPair::LinkPax => Currency::Link,
            &CurrencyPair::LinkTusd => Currency::Link,
            &CurrencyPair::LinkUsdc => Currency::Link,
            &CurrencyPair::LinkUsdt => Currency::Link,
            &CurrencyPair::LoomBnb => Currency::Loom,
            &CurrencyPair::LoomBtc => Currency::Loom,
            &CurrencyPair::LoomEth => Currency::Loom,
            &CurrencyPair::LrcBtc => Currency::Lrc,
            &CurrencyPair::LrcEth => Currency::Lrc,
            &CurrencyPair::LskBnb => Currency::Lsk,
            &CurrencyPair::LskBtc => Currency::Lsk,
            &CurrencyPair::LskEth => Currency::Lsk,
            &CurrencyPair::LtcBnb => Currency::Ltc,
            &CurrencyPair::LtcBtc => Currency::Ltc,
            &CurrencyPair::LtcBusd => Currency::Ltc,
            &CurrencyPair::LtcEth => Currency::Ltc,
            &CurrencyPair::LtcPax => Currency::Ltc,
            &CurrencyPair::LtcTusd => Currency::Ltc,
            &CurrencyPair::LtcUsdc => Currency::Ltc,
            &CurrencyPair::LtcUsdt => Currency::Ltc,
            &CurrencyPair::LunBtc => Currency::Lun,
            &CurrencyPair::LunEth => Currency::Lun,
            &CurrencyPair::ManaBtc => Currency::Mana,
            &CurrencyPair::ManaEth => Currency::Mana,
            &CurrencyPair::MaticBnb => Currency::Matic,
            &CurrencyPair::MaticBtc => Currency::Matic,
            &CurrencyPair::MaticUsdt => Currency::Matic,
            &CurrencyPair::McoBnb => Currency::Mco,
            &CurrencyPair::McoBtc => Currency::Mco,
            &CurrencyPair::McoEth => Currency::Mco,
            &CurrencyPair::McoUsdt => Currency::Mco,
            &CurrencyPair::MdaBtc => Currency::Mda,
            &CurrencyPair::MdaEth => Currency::Mda,
            &CurrencyPair::MftBnb => Currency::Mft,
            &CurrencyPair::MftBtc => Currency::Mft,
            &CurrencyPair::MftEth => Currency::Mft,
            &CurrencyPair::MftUsdt => Currency::Mft,
            &CurrencyPair::MithBnb => Currency::Mith,
            &CurrencyPair::MithBtc => Currency::Mith,
            &CurrencyPair::MithUsdt => Currency::Mith,
            &CurrencyPair::ModBtc => Currency::Mod,
            &CurrencyPair::ModEth => Currency::Mod,
            &CurrencyPair::MthBtc => Currency::Mth,
            &CurrencyPair::MthEth => Currency::Mth,
            &CurrencyPair::MtlBtc => Currency::Mtl,
            &CurrencyPair::MtlEth => Currency::Mtl,
            &CurrencyPair::MtlUsdt => Currency::Mtl,
            &CurrencyPair::NanoBnb => Currency::Nano,
            &CurrencyPair::NanoBtc => Currency::Nano,
            &CurrencyPair::NanoEth => Currency::Nano,
            &CurrencyPair::NanoUsdt => Currency::Nano,
            &CurrencyPair::NasBnb => Currency::Nas,
            &CurrencyPair::NasBtc => Currency::Nas,
            &CurrencyPair::NasEth => Currency::Nas,
            &CurrencyPair::NavBnb => Currency::Nav,
            &CurrencyPair::NavBtc => Currency::Nav,
            &CurrencyPair::NavEth => Currency::Nav,
            &CurrencyPair::NcashBnb => Currency::Ncash,
            &CurrencyPair::NcashBtc => Currency::Ncash,
            &CurrencyPair::NcashEth => Currency::Ncash,
            &CurrencyPair::NeblBnb => Currency::Nebl,
            &CurrencyPair::NeblBtc => Currency::Nebl,
            &CurrencyPair::NeblEth => Currency::Nebl,
            &CurrencyPair::NeoBnb => Currency::Neo,
            &CurrencyPair::NeoBtc => Currency::Neo,
            &CurrencyPair::NeoEth => Currency::Neo,
            &CurrencyPair::NeoPax => Currency::Neo,
            &CurrencyPair::NeoTusd => Currency::Neo,
            &CurrencyPair::NeoUsdc => Currency::Neo,
            &CurrencyPair::NeoUsdt => Currency::Neo,
            &CurrencyPair::NknBnb => Currency::Nkn,
            &CurrencyPair::NknBtc => Currency::Nkn,
            &CurrencyPair::NknUsdt => Currency::Nkn,
            &CurrencyPair::NpxsBtc => Currency::Npxs,
            &CurrencyPair::NpxsEth => Currency::Npxs,
            &CurrencyPair::NpxsUsdc => Currency::Npxs,
            &CurrencyPair::NpxsUsdt => Currency::Npxs,
            &CurrencyPair::NulsBnb => Currency::Nuls,
            &CurrencyPair::NulsBtc => Currency::Nuls,
            &CurrencyPair::NulsEth => Currency::Nuls,
            &CurrencyPair::NulsUsdt => Currency::Nuls,
            &CurrencyPair::NxsBnb => Currency::Nxs,
            &CurrencyPair::NxsBtc => Currency::Nxs,
            &CurrencyPair::NxsEth => Currency::Nxs,
            &CurrencyPair::OaxBtc => Currency::Oax,
            &CurrencyPair::OaxEth => Currency::Oax,
            &CurrencyPair::OmgBnb => Currency::Omg,
            &CurrencyPair::OmgBtc => Currency::Omg,
            &CurrencyPair::OmgEth => Currency::Omg,
            &CurrencyPair::OmgUsdt => Currency::Omg,
            &CurrencyPair::OneBnb => Currency::One,
            &CurrencyPair::OneBtc => Currency::One,
            &CurrencyPair::OnePax => Currency::One,
            &CurrencyPair::OneTusd => Currency::One,
            &CurrencyPair::OneUsdc => Currency::One,
            &CurrencyPair::OneUsdt => Currency::One,
            &CurrencyPair::OngBnb => Currency::Ong,
            &CurrencyPair::OngBtc => Currency::Ong,
            &CurrencyPair::OngUsdt => Currency::Ong,
            &CurrencyPair::OntBnb => Currency::Ont,
            &CurrencyPair::OntBtc => Currency::Ont,
            &CurrencyPair::OntEth => Currency::Ont,
            &CurrencyPair::OntPax => Currency::Ont,
            &CurrencyPair::OntUsdc => Currency::Ont,
            &CurrencyPair::OntUsdt => Currency::Ont,
            &CurrencyPair::OstBnb => Currency::Ost,
            &CurrencyPair::OstBtc => Currency::Ost,
            &CurrencyPair::OstEth => Currency::Ost,
            &CurrencyPair::PaxBnb => Currency::Pax,
            &CurrencyPair::PaxBtc => Currency::Pax,
            &CurrencyPair::PaxEth => Currency::Pax,
            &CurrencyPair::PaxTusd => Currency::Pax,
            &CurrencyPair::PaxUsdt => Currency::Pax,
            &CurrencyPair::PerlBnb => Currency::Perl,
            &CurrencyPair::PerlBtc => Currency::Perl,
            &CurrencyPair::PerlUsdc => Currency::Perl,
            &CurrencyPair::PerlUsdt => Currency::Perl,
            &CurrencyPair::PhbBnb => Currency::Phb,
            &CurrencyPair::PhbBtc => Currency::Phb,
            &CurrencyPair::PhbPax => Currency::Phb,
            &CurrencyPair::PhbTusd => Currency::Phb,
            &CurrencyPair::PhbUsdc => Currency::Phb,
            &CurrencyPair::PhxBnb => Currency::Phx,
            &CurrencyPair::PhxBtc => Currency::Phx,
            &CurrencyPair::PhxEth => Currency::Phx,
            &CurrencyPair::PivxBnb => Currency::Pivx,
            &CurrencyPair::PivxBtc => Currency::Pivx,
            &CurrencyPair::PivxEth => Currency::Pivx,
            &CurrencyPair::PoaBnb => Currency::Poa,
            &CurrencyPair::PoaBtc => Currency::Poa,
            &CurrencyPair::PoaEth => Currency::Poa,
            &CurrencyPair::PoeBtc => Currency::Poe,
            &CurrencyPair::PoeEth => Currency::Poe,
            &CurrencyPair::PolyBnb => Currency::Poly,
            &CurrencyPair::PolyBtc => Currency::Poly,
            &CurrencyPair::PowrBnb => Currency::Powr,
            &CurrencyPair::PowrBtc => Currency::Powr,
            &CurrencyPair::PowrEth => Currency::Powr,
            &CurrencyPair::PptBtc => Currency::Ppt,
            &CurrencyPair::PptEth => Currency::Ppt,
            &CurrencyPair::QkcBtc => Currency::Qkc,
            &CurrencyPair::QkcEth => Currency::Qkc,
            &CurrencyPair::QlcBnb => Currency::Qlc,
            &CurrencyPair::QlcBtc => Currency::Qlc,
            &CurrencyPair::QlcEth => Currency::Qlc,
            &CurrencyPair::QspBnb => Currency::Qsp,
            &CurrencyPair::QspBtc => Currency::Qsp,
            &CurrencyPair::QspEth => Currency::Qsp,
            &CurrencyPair::QtumBnb => Currency::Qtum,
            &CurrencyPair::QtumBtc => Currency::Qtum,
            &CurrencyPair::QtumBusd => Currency::Qtum,
            &CurrencyPair::QtumEth => Currency::Qtum,
            &CurrencyPair::QtumUsdt => Currency::Qtum,
            &CurrencyPair::RcnBnb => Currency::Rcn,
            &CurrencyPair::RcnBtc => Currency::Rcn,
            &CurrencyPair::RcnEth => Currency::Rcn,
            &CurrencyPair::RdnBnb => Currency::Rdn,
            &CurrencyPair::RdnBtc => Currency::Rdn,
            &CurrencyPair::RdnEth => Currency::Rdn,
            &CurrencyPair::RenBnb => Currency::Ren,
            &CurrencyPair::RenBtc => Currency::Ren,
            &CurrencyPair::RenUsdt => Currency::Ren,
            &CurrencyPair::RepBnb => Currency::Rep,
            &CurrencyPair::RepBtc => Currency::Rep,
            &CurrencyPair::RepEth => Currency::Rep,
            &CurrencyPair::ReqBtc => Currency::Req,
            &CurrencyPair::ReqEth => Currency::Req,
            &CurrencyPair::RlcBnb => Currency::Rlc,
            &CurrencyPair::RlcBtc => Currency::Rlc,
            &CurrencyPair::RlcEth => Currency::Rlc,
            &CurrencyPair::RlcUsdt => Currency::Rlc,
            &CurrencyPair::RpxBnb => Currency::Rpx,
            &CurrencyPair::RpxBtc => Currency::Rpx,
            &CurrencyPair::RpxEth => Currency::Rpx,
            &CurrencyPair::RvnBnb => Currency::Rvn,
            &CurrencyPair::RvnBtc => Currency::Rvn,
            &CurrencyPair::RvnUsdt => Currency::Rvn,
            &CurrencyPair::SaltBtc => Currency::Salt,
            &CurrencyPair::SaltEth => Currency::Salt,
            &CurrencyPair::ScBnb => Currency::Sc,
            &CurrencyPair::ScBtc => Currency::Sc,
            &CurrencyPair::ScEth => Currency::Sc,
            &CurrencyPair::SkyBnb => Currency::Sky,
            &CurrencyPair::SkyBtc => Currency::Sky,
            &CurrencyPair::SkyEth => Currency::Sky,
            &CurrencyPair::SnglsBtc => Currency::Sngls,
            &CurrencyPair::SnglsEth => Currency::Sngls,
            &CurrencyPair::SnmBtc => Currency::Snm,
            &CurrencyPair::SnmEth => Currency::Snm,
            &CurrencyPair::SntBtc => Currency::Snt,
            &CurrencyPair::SntEth => Currency::Snt,
            &CurrencyPair::SteemBnb => Currency::Steem,
            &CurrencyPair::SteemBtc => Currency::Steem,
            &CurrencyPair::SteemEth => Currency::Steem,
            &CurrencyPair::StorjBtc => Currency::Storj,
            &CurrencyPair::StorjEth => Currency::Storj,
            &CurrencyPair::StormBnb => Currency::Storm,
            &CurrencyPair::StormBtc => Currency::Storm,
            &CurrencyPair::StormEth => Currency::Storm,
            &CurrencyPair::StormUsdt => Currency::Storm,
            &CurrencyPair::StratBtc => Currency::Strat,
            &CurrencyPair::StratEth => Currency::Strat,
            &CurrencyPair::StxBnb => Currency::Stx,
            &CurrencyPair::StxBtc => Currency::Stx,
            &CurrencyPair::StxUsdt => Currency::Stx,
            &CurrencyPair::SubBtc => Currency::Sub,
            &CurrencyPair::SubEth => Currency::Sub,
            &CurrencyPair::SysBnb => Currency::Sys,
            &CurrencyPair::SysBtc => Currency::Sys,
            &CurrencyPair::SysEth => Currency::Sys,
            &CurrencyPair::TfuelBnb => Currency::Tfuel,
            &CurrencyPair::TfuelBtc => Currency::Tfuel,
            &CurrencyPair::TfuelPax => Currency::Tfuel,
            &CurrencyPair::TfuelTusd => Currency::Tfuel,
            &CurrencyPair::TfuelUsdc => Currency::Tfuel,
            &CurrencyPair::TfuelUsdt => Currency::Tfuel,
            &CurrencyPair::ThetaBnb => Currency::Theta,
            &CurrencyPair::ThetaBtc => Currency::Theta,
            &CurrencyPair::ThetaEth => Currency::Theta,
            &CurrencyPair::ThetaUsdt => Currency::Theta,
            &CurrencyPair::TnbBtc => Currency::Tnb,
            &CurrencyPair::TnbEth => Currency::Tnb,
            &CurrencyPair::TntBtc => Currency::Tnt,
            &CurrencyPair::TntEth => Currency::Tnt,
            &CurrencyPair::TomoBnb => Currency::Tomo,
            &CurrencyPair::TomoBtc => Currency::Tomo,
            &CurrencyPair::TomoUsdc => Currency::Tomo,
            &CurrencyPair::TomoUsdt => Currency::Tomo,
            &CurrencyPair::TrigBnb => Currency::Trig,
            &CurrencyPair::TrigBtc => Currency::Trig,
            &CurrencyPair::TrigEth => Currency::Trig,
            &CurrencyPair::TroyBnb => Currency::Troy,
            &CurrencyPair::TroyBtc => Currency::Troy,
            &CurrencyPair::TroyUsdt => Currency::Troy,
            &CurrencyPair::TrxBnb => Currency::Trx,
            &CurrencyPair::TrxBtc => Currency::Trx,
            &CurrencyPair::TrxBusd => Currency::Trx,
            &CurrencyPair::TrxEth => Currency::Trx,
            &CurrencyPair::TrxPax => Currency::Trx,
            &CurrencyPair::TrxTusd => Currency::Trx,
            &CurrencyPair::TrxUsdc => Currency::Trx,
            &CurrencyPair::TrxUsdt => Currency::Trx,
            &CurrencyPair::TrxXrp => Currency::Trx,
            &CurrencyPair::TusdbTusd => Currency::Tusdb,
            &CurrencyPair::TusdBnb => Currency::Tusd,
            &CurrencyPair::TusdBtc => Currency::Tusd,
            &CurrencyPair::TusdEth => Currency::Tusd,
            &CurrencyPair::TusdUsdt => Currency::Tusd,
            &CurrencyPair::UsdcBnb => Currency::Usdc,
            &CurrencyPair::UsdcDash => Currency::Usdc,
            &CurrencyPair::UsdcGrin => Currency::Usdc,
            &CurrencyPair::UsdcPax => Currency::Usdc,
            &CurrencyPair::UsdcStr => Currency::Usdc,
            &CurrencyPair::UsdcTusd => Currency::Usdc,
            &CurrencyPair::UsdcUsdt => Currency::Usdc,
            &CurrencyPair::UsdcXmr => Currency::Usdc,
            &CurrencyPair::UsdsbUsds => Currency::Usdsb,
            &CurrencyPair::UsdsbUsdt => Currency::Usdsb,
            &CurrencyPair::UsdsPax => Currency::Usds,
            &CurrencyPair::UsdsTusd => Currency::Usds,
            &CurrencyPair::UsdsUsdc => Currency::Usds,
            &CurrencyPair::UsdsUsdt => Currency::Usds,
            &CurrencyPair::UsdtDgb => Currency::Usdt,
            &CurrencyPair::UsdtGnt => Currency::Usdt,
            &CurrencyPair::UsdtGrin => Currency::Usdt,
            &CurrencyPair::UsdtLsk => Currency::Usdt,
            &CurrencyPair::UsdtMana => Currency::Usdt,
            &CurrencyPair::UsdtNxt => Currency::Usdt,
            &CurrencyPair::UsdtRep => Currency::Usdt,
            &CurrencyPair::UsdtRub => Currency::Usdt,
            &CurrencyPair::UsdtSc => Currency::Usdt,
            &CurrencyPair::UsdtStr => Currency::Usdt,
            &CurrencyPair::UsdtTry => Currency::Usdt,
            &CurrencyPair::VenBnb => Currency::Ven,
            &CurrencyPair::VenBtc => Currency::Ven,
            &CurrencyPair::VenEth => Currency::Ven,
            &CurrencyPair::VenUsdt => Currency::Ven,
            &CurrencyPair::VetBnb => Currency::Vet,
            &CurrencyPair::VetBtc => Currency::Vet,
            &CurrencyPair::VetBusd => Currency::Vet,
            &CurrencyPair::VetEth => Currency::Vet,
            &CurrencyPair::VetUsdt => Currency::Vet,
            &CurrencyPair::ViaBnb => Currency::Via,
            &CurrencyPair::ViaBtc => Currency::Via,
            &CurrencyPair::ViaEth => Currency::Via,
            &CurrencyPair::VibeBtc => Currency::Vibe,
            &CurrencyPair::VibeEth => Currency::Vibe,
            &CurrencyPair::VibBtc => Currency::Vib,
            &CurrencyPair::VibEth => Currency::Vib,
            &CurrencyPair::ViteBnb => Currency::Vite,
            &CurrencyPair::ViteBtc => Currency::Vite,
            &CurrencyPair::ViteUsdt => Currency::Vite,
            &CurrencyPair::WabiBnb => Currency::Wabi,
            &CurrencyPair::WabiBtc => Currency::Wabi,
            &CurrencyPair::WabiEth => Currency::Wabi,
            &CurrencyPair::WanBnb => Currency::Wan,
            &CurrencyPair::WanBtc => Currency::Wan,
            &CurrencyPair::WanEth => Currency::Wan,
            &CurrencyPair::WanUsdt => Currency::Wan,
            &CurrencyPair::WavesBnb => Currency::Waves,
            &CurrencyPair::WavesBtc => Currency::Waves,
            &CurrencyPair::WavesEth => Currency::Waves,
            &CurrencyPair::WavesPax => Currency::Waves,
            &CurrencyPair::WavesTusd => Currency::Waves,
            &CurrencyPair::WavesUsdc => Currency::Waves,
            &CurrencyPair::WavesUsdt => Currency::Waves,
            &CurrencyPair::WingsBtc => Currency::Wings,
            &CurrencyPair::WingsEth => Currency::Wings,
            &CurrencyPair::WinBnb => Currency::Win,
            &CurrencyPair::WinBtc => Currency::Win,
            &CurrencyPair::WinTrx => Currency::Win,
            &CurrencyPair::WinUsdc => Currency::Win,
            &CurrencyPair::WinUsdt => Currency::Win,
            &CurrencyPair::WprBtc => Currency::Wpr,
            &CurrencyPair::WprEth => Currency::Wpr,
            &CurrencyPair::WtcBnb => Currency::Wtc,
            &CurrencyPair::WtcBtc => Currency::Wtc,
            &CurrencyPair::WtcEth => Currency::Wtc,
            &CurrencyPair::XemBnb => Currency::Xem,
            &CurrencyPair::XemBtc => Currency::Xem,
            &CurrencyPair::XemEth => Currency::Xem,
            &CurrencyPair::XlmBnb => Currency::Xlm,
            &CurrencyPair::XlmBtc => Currency::Xlm,
            &CurrencyPair::XlmBusd => Currency::Xlm,
            &CurrencyPair::XlmEth => Currency::Xlm,
            &CurrencyPair::XlmPax => Currency::Xlm,
            &CurrencyPair::XlmTusd => Currency::Xlm,
            &CurrencyPair::XlmUsdc => Currency::Xlm,
            &CurrencyPair::XlmUsdt => Currency::Xlm,
            &CurrencyPair::XmrBnb => Currency::Xmr,
            &CurrencyPair::XmrBtc => Currency::Xmr,
            &CurrencyPair::XmrEth => Currency::Xmr,
            &CurrencyPair::XmrUsdt => Currency::Xmr,
            &CurrencyPair::XrpBnb => Currency::Xrp,
            &CurrencyPair::XrpBtc => Currency::Xrp,
            &CurrencyPair::XrpBusd => Currency::Xrp,
            &CurrencyPair::XrpEth => Currency::Xrp,
            &CurrencyPair::XrpPax => Currency::Xrp,
            &CurrencyPair::XrpRub => Currency::Xrp,
            &CurrencyPair::XrpTry => Currency::Xrp,
            &CurrencyPair::XrpTusd => Currency::Xrp,
            &CurrencyPair::XrpUsdc => Currency::Xrp,
            &CurrencyPair::XrpUsdt => Currency::Xrp,
            &CurrencyPair::XtzBnb => Currency::Xtz,
            &CurrencyPair::XtzBtc => Currency::Xtz,
            &CurrencyPair::XtzUsdt => Currency::Xtz,
            &CurrencyPair::XvgBtc => Currency::Xvg,
            &CurrencyPair::XvgEth => Currency::Xvg,
            &CurrencyPair::XzcBnb => Currency::Xzc,
            &CurrencyPair::XzcBtc => Currency::Xzc,
            &CurrencyPair::XzcEth => Currency::Xzc,
            &CurrencyPair::XzcXrp => Currency::Xzc,
            &CurrencyPair::YoyoBnb => Currency::Yoyo,
            &CurrencyPair::YoyoBtc => Currency::Yoyo,
            &CurrencyPair::YoyoEth => Currency::Yoyo,
            &CurrencyPair::ZecBnb => Currency::Zec,
            &CurrencyPair::ZecBtc => Currency::Zec,
            &CurrencyPair::ZecEth => Currency::Zec,
            &CurrencyPair::ZecPax => Currency::Zec,
            &CurrencyPair::ZecTusd => Currency::Zec,
            &CurrencyPair::ZecUsdc => Currency::Zec,
            &CurrencyPair::ZecUsdt => Currency::Zec,
            &CurrencyPair::ZenBnb => Currency::Zen,
            &CurrencyPair::ZenBtc => Currency::Zen,
            &CurrencyPair::ZenEth => Currency::Zen,
            &CurrencyPair::ZilBnb => Currency::Zil,
            &CurrencyPair::ZilBtc => Currency::Zil,
            &CurrencyPair::ZilEth => Currency::Zil,
            &CurrencyPair::ZilUsdt => Currency::Zil,
            &CurrencyPair::ZrxBnb => Currency::Zrx,
            &CurrencyPair::ZrxBtc => Currency::Zrx,
            &CurrencyPair::ZrxEth => Currency::Zrx,
            &CurrencyPair::ZrxUsdt => Currency::Zrx,
        }
    }

    pub fn base(&self) -> Currency {
        match self {
            CurrencyPair::Custom(_, _, ref base) => base.clone(),
            &CurrencyPair::AdaBnb => Currency::Bnb,
            &CurrencyPair::AdaBtc => Currency::Btc,
            &CurrencyPair::AdaBusd => Currency::Busd,
            &CurrencyPair::AdaEth => Currency::Eth,
            &CurrencyPair::AdaPax => Currency::Pax,
            &CurrencyPair::AdaTusd => Currency::Tusd,
            &CurrencyPair::AdaUsdc => Currency::Usdc,
            &CurrencyPair::AdaUsdt => Currency::Usdt,
            &CurrencyPair::AdxBnb => Currency::Bnb,
            &CurrencyPair::AdxBtc => Currency::Btc,
            &CurrencyPair::AdxEth => Currency::Eth,
            &CurrencyPair::AeBnb => Currency::Bnb,
            &CurrencyPair::AeBtc => Currency::Btc,
            &CurrencyPair::AeEth => Currency::Eth,
            &CurrencyPair::AgiBnb => Currency::Bnb,
            &CurrencyPair::AgiBtc => Currency::Btc,
            &CurrencyPair::AgiEth => Currency::Eth,
            &CurrencyPair::AionBnb => Currency::Bnb,
            &CurrencyPair::AionBtc => Currency::Btc,
            &CurrencyPair::AionEth => Currency::Eth,
            &CurrencyPair::AlgoBnb => Currency::Bnb,
            &CurrencyPair::AlgoBtc => Currency::Btc,
            &CurrencyPair::AlgoPax => Currency::Pax,
            &CurrencyPair::AlgoTusd => Currency::Tusd,
            &CurrencyPair::AlgoUsdc => Currency::Usdc,
            &CurrencyPair::AlgoUsdt => Currency::Usdt,
            &CurrencyPair::AmbBnb => Currency::Bnb,
            &CurrencyPair::AmbBtc => Currency::Btc,
            &CurrencyPair::AmbEth => Currency::Eth,
            &CurrencyPair::AnkrBnb => Currency::Bnb,
            &CurrencyPair::AnkrBtc => Currency::Btc,
            &CurrencyPair::AnkrPax => Currency::Pax,
            &CurrencyPair::AnkrTusd => Currency::Tusd,
            &CurrencyPair::AnkrUsdc => Currency::Usdc,
            &CurrencyPair::AnkrUsdt => Currency::Usdt,
            &CurrencyPair::AppcBnb => Currency::Bnb,
            &CurrencyPair::AppcBtc => Currency::Btc,
            &CurrencyPair::AppcEth => Currency::Eth,
            &CurrencyPair::ArdrBnb => Currency::Bnb,
            &CurrencyPair::ArdrBtc => Currency::Btc,
            &CurrencyPair::ArdrEth => Currency::Eth,
            &CurrencyPair::ArkBtc => Currency::Btc,
            &CurrencyPair::ArkEth => Currency::Eth,
            &CurrencyPair::ArnBtc => Currency::Btc,
            &CurrencyPair::ArnEth => Currency::Eth,
            &CurrencyPair::ArpaBnb => Currency::Bnb,
            &CurrencyPair::ArpaBtc => Currency::Btc,
            &CurrencyPair::ArpaUsdt => Currency::Usdt,
            &CurrencyPair::AstBtc => Currency::Btc,
            &CurrencyPair::AstEth => Currency::Eth,
            &CurrencyPair::AtomBnb => Currency::Bnb,
            &CurrencyPair::AtomBtc => Currency::Btc,
            &CurrencyPair::AtomPax => Currency::Pax,
            &CurrencyPair::AtomTusd => Currency::Tusd,
            &CurrencyPair::AtomUsdc => Currency::Usdc,
            &CurrencyPair::AtomUsdt => Currency::Usdt,
            &CurrencyPair::BandBnb => Currency::Bnb,
            &CurrencyPair::BandBtc => Currency::Btc,
            &CurrencyPair::BandUsdt => Currency::Usdt,
            &CurrencyPair::BatBnb => Currency::Bnb,
            &CurrencyPair::BatBtc => Currency::Btc,
            &CurrencyPair::BatEth => Currency::Eth,
            &CurrencyPair::BatPax => Currency::Pax,
            &CurrencyPair::BatTusd => Currency::Tusd,
            &CurrencyPair::BatUsdc => Currency::Usdc,
            &CurrencyPair::BatUsdt => Currency::Usdt,
            &CurrencyPair::BccBnb => Currency::Bnb,
            &CurrencyPair::BccBtc => Currency::Btc,
            &CurrencyPair::BccEth => Currency::Eth,
            &CurrencyPair::BccUsdt => Currency::Usdt,
            &CurrencyPair::BcdBtc => Currency::Btc,
            &CurrencyPair::BcdEth => Currency::Eth,
            &CurrencyPair::BchabcBtc => Currency::Btc,
            &CurrencyPair::BchabcBusd => Currency::Busd,
            &CurrencyPair::BchabcPax => Currency::Pax,
            &CurrencyPair::BchabcTusd => Currency::Tusd,
            &CurrencyPair::BchabcUsdc => Currency::Usdc,
            &CurrencyPair::BchabcUsdt => Currency::Usdt,
            &CurrencyPair::BchsvBtc => Currency::Btc,
            &CurrencyPair::BchsvPax => Currency::Pax,
            &CurrencyPair::BchsvTusd => Currency::Tusd,
            &CurrencyPair::BchsvUsdc => Currency::Usdc,
            &CurrencyPair::BchsvUsdt => Currency::Usdt,
            &CurrencyPair::BchBnb => Currency::Bnb,
            &CurrencyPair::BchBtc => Currency::Btc,
            &CurrencyPair::BchBusd => Currency::Busd,
            &CurrencyPair::BchPax => Currency::Pax,
            &CurrencyPair::BchTusd => Currency::Tusd,
            &CurrencyPair::BchUsdc => Currency::Usdc,
            &CurrencyPair::BchUsdt => Currency::Usdt,
            &CurrencyPair::BcnBnb => Currency::Bnb,
            &CurrencyPair::BcnBtc => Currency::Btc,
            &CurrencyPair::BcnEth => Currency::Eth,
            &CurrencyPair::BcptBnb => Currency::Bnb,
            &CurrencyPair::BcptBtc => Currency::Btc,
            &CurrencyPair::BcptEth => Currency::Eth,
            &CurrencyPair::BcptPax => Currency::Pax,
            &CurrencyPair::BcptTusd => Currency::Tusd,
            &CurrencyPair::BcptUsdc => Currency::Usdc,
            &CurrencyPair::BeamBnb => Currency::Bnb,
            &CurrencyPair::BeamBtc => Currency::Btc,
            &CurrencyPair::BeamUsdt => Currency::Usdt,
            &CurrencyPair::BgbpUsdc => Currency::Usdc,
            &CurrencyPair::BlzBnb => Currency::Bnb,
            &CurrencyPair::BlzBtc => Currency::Btc,
            &CurrencyPair::BlzEth => Currency::Eth,
            &CurrencyPair::BnbBtc => Currency::Btc,
            &CurrencyPair::BnbBusd => Currency::Busd,
            &CurrencyPair::BnbEth => Currency::Eth,
            &CurrencyPair::BnbNgn => Currency::Ngn,
            &CurrencyPair::BnbPax => Currency::Pax,
            &CurrencyPair::BnbRub => Currency::Rub,
            &CurrencyPair::BnbTry => Currency::Try,
            &CurrencyPair::BnbTusd => Currency::Tusd,
            &CurrencyPair::BnbUsdc => Currency::Usdc,
            &CurrencyPair::BnbUsds => Currency::Usds,
            &CurrencyPair::BnbUsdt => Currency::Usdt,
            &CurrencyPair::BntBtc => Currency::Btc,
            &CurrencyPair::BntEth => Currency::Eth,
            &CurrencyPair::BqxBtc => Currency::Btc,
            &CurrencyPair::BqxEth => Currency::Eth,
            &CurrencyPair::BrdBnb => Currency::Bnb,
            &CurrencyPair::BrdBtc => Currency::Btc,
            &CurrencyPair::BrdEth => Currency::Eth,
            &CurrencyPair::BtcbBtc => Currency::Btc,
            &CurrencyPair::BtcBusd => Currency::Busd,
            &CurrencyPair::BtcDgb => Currency::Dgb,
            &CurrencyPair::BtcFct => Currency::Fct,
            &CurrencyPair::BtcFoam => Currency::Foam,
            &CurrencyPair::BtcGrin => Currency::Grin,
            &CurrencyPair::BtcLpt => Currency::Lpt,
            &CurrencyPair::BtcMaid => Currency::Maid,
            &CurrencyPair::BtcNgn => Currency::Ngn,
            &CurrencyPair::BtcNmr => Currency::Nmr,
            &CurrencyPair::BtcNxt => Currency::Nxt,
            &CurrencyPair::BtcOmni => Currency::Omni,
            &CurrencyPair::BtcPax => Currency::Pax,
            &CurrencyPair::BtcRub => Currency::Rub,
            &CurrencyPair::BtcStr => Currency::Str,
            &CurrencyPair::BtcTry => Currency::Try,
            &CurrencyPair::BtcTusd => Currency::Tusd,
            &CurrencyPair::BtcUsdc => Currency::Usdc,
            &CurrencyPair::BtcUsds => Currency::Usds,
            &CurrencyPair::BtcUsdt => Currency::Usdt,
            &CurrencyPair::BtcVtc => Currency::Vtc,
            &CurrencyPair::BtcXpm => Currency::Xpm,
            &CurrencyPair::BtgBtc => Currency::Btc,
            &CurrencyPair::BtgEth => Currency::Eth,
            &CurrencyPair::BtsBnb => Currency::Bnb,
            &CurrencyPair::BtsBtc => Currency::Btc,
            &CurrencyPair::BtsEth => Currency::Eth,
            &CurrencyPair::BttBnb => Currency::Bnb,
            &CurrencyPair::BttBtc => Currency::Btc,
            &CurrencyPair::BttPax => Currency::Pax,
            &CurrencyPair::BttTrx => Currency::Trx,
            &CurrencyPair::BttTusd => Currency::Tusd,
            &CurrencyPair::BttUsdc => Currency::Usdc,
            &CurrencyPair::BttUsdt => Currency::Usdt,
            &CurrencyPair::BusdNgn => Currency::Ngn,
            &CurrencyPair::BusdRub => Currency::Rub,
            &CurrencyPair::BusdTry => Currency::Try,
            &CurrencyPair::BusdUsdt => Currency::Usdt,
            &CurrencyPair::CdtBtc => Currency::Btc,
            &CurrencyPair::CdtEth => Currency::Eth,
            &CurrencyPair::CelrBnb => Currency::Bnb,
            &CurrencyPair::CelrBtc => Currency::Btc,
            &CurrencyPair::CelrUsdt => Currency::Usdt,
            &CurrencyPair::ChatBtc => Currency::Btc,
            &CurrencyPair::ChatEth => Currency::Eth,
            &CurrencyPair::ChzBnb => Currency::Bnb,
            &CurrencyPair::ChzBtc => Currency::Btc,
            &CurrencyPair::ChzUsdt => Currency::Usdt,
            &CurrencyPair::CloakBtc => Currency::Btc,
            &CurrencyPair::CloakEth => Currency::Eth,
            &CurrencyPair::CmtBnb => Currency::Bnb,
            &CurrencyPair::CmtBtc => Currency::Btc,
            &CurrencyPair::CmtEth => Currency::Eth,
            &CurrencyPair::CndBnb => Currency::Bnb,
            &CurrencyPair::CndBtc => Currency::Btc,
            &CurrencyPair::CndEth => Currency::Eth,
            &CurrencyPair::CocosBnb => Currency::Bnb,
            &CurrencyPair::CocosBtc => Currency::Btc,
            &CurrencyPair::CocosUsdt => Currency::Usdt,
            &CurrencyPair::CosBnb => Currency::Bnb,
            &CurrencyPair::CosBtc => Currency::Btc,
            &CurrencyPair::CosUsdt => Currency::Usdt,
            &CurrencyPair::CtxcBnb => Currency::Bnb,
            &CurrencyPair::CtxcBtc => Currency::Btc,
            &CurrencyPair::CtxcUsdt => Currency::Usdt,
            &CurrencyPair::CvcBnb => Currency::Bnb,
            &CurrencyPair::CvcBtc => Currency::Btc,
            &CurrencyPair::CvcEth => Currency::Eth,
            &CurrencyPair::CvcUsdt => Currency::Usdt,
            &CurrencyPair::DashBnb => Currency::Bnb,
            &CurrencyPair::DashBtc => Currency::Btc,
            &CurrencyPair::DashEth => Currency::Eth,
            &CurrencyPair::DashUsdt => Currency::Usdt,
            &CurrencyPair::DataBtc => Currency::Btc,
            &CurrencyPair::DataEth => Currency::Eth,
            &CurrencyPair::DcrBnb => Currency::Bnb,
            &CurrencyPair::DcrBtc => Currency::Btc,
            &CurrencyPair::DentBtc => Currency::Btc,
            &CurrencyPair::DentEth => Currency::Eth,
            &CurrencyPair::DentUsdt => Currency::Usdt,
            &CurrencyPair::DgdBtc => Currency::Btc,
            &CurrencyPair::DgdEth => Currency::Eth,
            &CurrencyPair::DltBnb => Currency::Bnb,
            &CurrencyPair::DltBtc => Currency::Btc,
            &CurrencyPair::DltEth => Currency::Eth,
            &CurrencyPair::DntBtc => Currency::Btc,
            &CurrencyPair::DntEth => Currency::Eth,
            &CurrencyPair::DockBtc => Currency::Btc,
            &CurrencyPair::DockEth => Currency::Eth,
            &CurrencyPair::DockUsdt => Currency::Usdt,
            &CurrencyPair::DogeBnb => Currency::Bnb,
            &CurrencyPair::DogeBtc => Currency::Btc,
            &CurrencyPair::DogePax => Currency::Pax,
            &CurrencyPair::DogeUsdc => Currency::Usdc,
            &CurrencyPair::DogeUsdt => Currency::Usdt,
            &CurrencyPair::DuskBnb => Currency::Bnb,
            &CurrencyPair::DuskBtc => Currency::Btc,
            &CurrencyPair::DuskPax => Currency::Pax,
            &CurrencyPair::DuskUsdc => Currency::Usdc,
            &CurrencyPair::DuskUsdt => Currency::Usdt,
            &CurrencyPair::EdoBtc => Currency::Btc,
            &CurrencyPair::EdoEth => Currency::Eth,
            &CurrencyPair::ElfBtc => Currency::Btc,
            &CurrencyPair::ElfEth => Currency::Eth,
            &CurrencyPair::EngBtc => Currency::Btc,
            &CurrencyPair::EngEth => Currency::Eth,
            &CurrencyPair::EnjBnb => Currency::Bnb,
            &CurrencyPair::EnjBtc => Currency::Btc,
            &CurrencyPair::EnjEth => Currency::Eth,
            &CurrencyPair::EnjUsdt => Currency::Usdt,
            &CurrencyPair::EosBnb => Currency::Bnb,
            &CurrencyPair::EosBtc => Currency::Btc,
            &CurrencyPair::EosBusd => Currency::Busd,
            &CurrencyPair::EosEth => Currency::Eth,
            &CurrencyPair::EosPax => Currency::Pax,
            &CurrencyPair::EosTusd => Currency::Tusd,
            &CurrencyPair::EosUsdc => Currency::Usdc,
            &CurrencyPair::EosUsdt => Currency::Usdt,
            &CurrencyPair::ErdBnb => Currency::Bnb,
            &CurrencyPair::ErdBtc => Currency::Btc,
            &CurrencyPair::ErdPax => Currency::Pax,
            &CurrencyPair::ErdUsdc => Currency::Usdc,
            &CurrencyPair::ErdUsdt => Currency::Usdt,
            &CurrencyPair::EtcBnb => Currency::Bnb,
            &CurrencyPair::EtcBtc => Currency::Btc,
            &CurrencyPair::EtcBusd => Currency::Busd,
            &CurrencyPair::EtcEth => Currency::Eth,
            &CurrencyPair::EtcPax => Currency::Pax,
            &CurrencyPair::EtcTusd => Currency::Tusd,
            &CurrencyPair::EtcUsdc => Currency::Usdc,
            &CurrencyPair::EtcUsdt => Currency::Usdt,
            &CurrencyPair::EthBtc => Currency::Btc,
            &CurrencyPair::EthBusd => Currency::Busd,
            &CurrencyPair::EthPax => Currency::Pax,
            &CurrencyPair::EthRub => Currency::Rub,
            &CurrencyPair::EthTry => Currency::Try,
            &CurrencyPair::EthTusd => Currency::Tusd,
            &CurrencyPair::EthUsdc => Currency::Usdc,
            &CurrencyPair::EthUsdt => Currency::Usdt,
            &CurrencyPair::EvxBtc => Currency::Btc,
            &CurrencyPair::EvxEth => Currency::Eth,
            &CurrencyPair::FetBnb => Currency::Bnb,
            &CurrencyPair::FetBtc => Currency::Btc,
            &CurrencyPair::FetUsdt => Currency::Usdt,
            &CurrencyPair::FtmBnb => Currency::Bnb,
            &CurrencyPair::FtmBtc => Currency::Btc,
            &CurrencyPair::FtmPax => Currency::Pax,
            &CurrencyPair::FtmTusd => Currency::Tusd,
            &CurrencyPair::FtmUsdc => Currency::Usdc,
            &CurrencyPair::FtmUsdt => Currency::Usdt,
            &CurrencyPair::FttBnb => Currency::Bnb,
            &CurrencyPair::FttBtc => Currency::Btc,
            &CurrencyPair::FttUsdt => Currency::Usdt,
            &CurrencyPair::FuelBtc => Currency::Btc,
            &CurrencyPair::FuelEth => Currency::Eth,
            &CurrencyPair::FunBtc => Currency::Btc,
            &CurrencyPair::FunEth => Currency::Eth,
            &CurrencyPair::FunUsdt => Currency::Usdt,
            &CurrencyPair::GasBtc => Currency::Btc,
            &CurrencyPair::GntBnb => Currency::Bnb,
            &CurrencyPair::GntBtc => Currency::Btc,
            &CurrencyPair::GntEth => Currency::Eth,
            &CurrencyPair::GoBnb => Currency::Bnb,
            &CurrencyPair::GoBtc => Currency::Btc,
            &CurrencyPair::GrsBtc => Currency::Btc,
            &CurrencyPair::GrsEth => Currency::Eth,
            &CurrencyPair::GtoBnb => Currency::Bnb,
            &CurrencyPair::GtoBtc => Currency::Btc,
            &CurrencyPair::GtoEth => Currency::Eth,
            &CurrencyPair::GtoPax => Currency::Pax,
            &CurrencyPair::GtoTusd => Currency::Tusd,
            &CurrencyPair::GtoUsdc => Currency::Usdc,
            &CurrencyPair::GtoUsdt => Currency::Usdt,
            &CurrencyPair::GvtBtc => Currency::Btc,
            &CurrencyPair::GvtEth => Currency::Eth,
            &CurrencyPair::GxsBtc => Currency::Btc,
            &CurrencyPair::GxsEth => Currency::Eth,
            &CurrencyPair::HbarBnb => Currency::Bnb,
            &CurrencyPair::HbarBtc => Currency::Btc,
            &CurrencyPair::HbarUsdt => Currency::Usdt,
            &CurrencyPair::HcBtc => Currency::Btc,
            &CurrencyPair::HcEth => Currency::Eth,
            &CurrencyPair::HcUsdt => Currency::Usdt,
            &CurrencyPair::HotBnb => Currency::Bnb,
            &CurrencyPair::HotBtc => Currency::Btc,
            &CurrencyPair::HotEth => Currency::Eth,
            &CurrencyPair::HotUsdt => Currency::Usdt,
            &CurrencyPair::HsrBtc => Currency::Btc,
            &CurrencyPair::HsrEth => Currency::Eth,
            &CurrencyPair::IcnBtc => Currency::Btc,
            &CurrencyPair::IcnEth => Currency::Eth,
            &CurrencyPair::IcxBnb => Currency::Bnb,
            &CurrencyPair::IcxBtc => Currency::Btc,
            &CurrencyPair::IcxEth => Currency::Eth,
            &CurrencyPair::IcxUsdt => Currency::Usdt,
            &CurrencyPair::InsBtc => Currency::Btc,
            &CurrencyPair::InsEth => Currency::Eth,
            &CurrencyPair::IostBnb => Currency::Bnb,
            &CurrencyPair::IostBtc => Currency::Btc,
            &CurrencyPair::IostEth => Currency::Eth,
            &CurrencyPair::IostUsdt => Currency::Usdt,
            &CurrencyPair::IotaBnb => Currency::Bnb,
            &CurrencyPair::IotaBtc => Currency::Btc,
            &CurrencyPair::IotaEth => Currency::Eth,
            &CurrencyPair::IotaUsdt => Currency::Usdt,
            &CurrencyPair::IotxBtc => Currency::Btc,
            &CurrencyPair::IotxEth => Currency::Eth,
            &CurrencyPair::IotxUsdt => Currency::Usdt,
            &CurrencyPair::KavaBnb => Currency::Bnb,
            &CurrencyPair::KavaBtc => Currency::Btc,
            &CurrencyPair::KavaUsdt => Currency::Usdt,
            &CurrencyPair::KeyBtc => Currency::Btc,
            &CurrencyPair::KeyEth => Currency::Eth,
            &CurrencyPair::KeyUsdt => Currency::Usdt,
            &CurrencyPair::KmdBtc => Currency::Btc,
            &CurrencyPair::KmdEth => Currency::Eth,
            &CurrencyPair::KncBtc => Currency::Btc,
            &CurrencyPair::KncEth => Currency::Eth,
            &CurrencyPair::LendBtc => Currency::Btc,
            &CurrencyPair::LendEth => Currency::Eth,
            &CurrencyPair::LinkBtc => Currency::Btc,
            &CurrencyPair::LinkBusd => Currency::Busd,
            &CurrencyPair::LinkEth => Currency::Eth,
            &CurrencyPair::LinkPax => Currency::Pax,
            &CurrencyPair::LinkTusd => Currency::Tusd,
            &CurrencyPair::LinkUsdc => Currency::Usdc,
            &CurrencyPair::LinkUsdt => Currency::Usdt,
            &CurrencyPair::LoomBnb => Currency::Bnb,
            &CurrencyPair::LoomBtc => Currency::Btc,
            &CurrencyPair::LoomEth => Currency::Eth,
            &CurrencyPair::LrcBtc => Currency::Btc,
            &CurrencyPair::LrcEth => Currency::Eth,
            &CurrencyPair::LskBnb => Currency::Bnb,
            &CurrencyPair::LskBtc => Currency::Btc,
            &CurrencyPair::LskEth => Currency::Eth,
            &CurrencyPair::LtcBnb => Currency::Bnb,
            &CurrencyPair::LtcBtc => Currency::Btc,
            &CurrencyPair::LtcBusd => Currency::Busd,
            &CurrencyPair::LtcEth => Currency::Eth,
            &CurrencyPair::LtcPax => Currency::Pax,
            &CurrencyPair::LtcTusd => Currency::Tusd,
            &CurrencyPair::LtcUsdc => Currency::Usdc,
            &CurrencyPair::LtcUsdt => Currency::Usdt,
            &CurrencyPair::LunBtc => Currency::Btc,
            &CurrencyPair::LunEth => Currency::Eth,
            &CurrencyPair::ManaBtc => Currency::Btc,
            &CurrencyPair::ManaEth => Currency::Eth,
            &CurrencyPair::MaticBnb => Currency::Bnb,
            &CurrencyPair::MaticBtc => Currency::Btc,
            &CurrencyPair::MaticUsdt => Currency::Usdt,
            &CurrencyPair::McoBnb => Currency::Bnb,
            &CurrencyPair::McoBtc => Currency::Btc,
            &CurrencyPair::McoEth => Currency::Eth,
            &CurrencyPair::McoUsdt => Currency::Usdt,
            &CurrencyPair::MdaBtc => Currency::Btc,
            &CurrencyPair::MdaEth => Currency::Eth,
            &CurrencyPair::MftBnb => Currency::Bnb,
            &CurrencyPair::MftBtc => Currency::Btc,
            &CurrencyPair::MftEth => Currency::Eth,
            &CurrencyPair::MftUsdt => Currency::Usdt,
            &CurrencyPair::MithBnb => Currency::Bnb,
            &CurrencyPair::MithBtc => Currency::Btc,
            &CurrencyPair::MithUsdt => Currency::Usdt,
            &CurrencyPair::ModBtc => Currency::Btc,
            &CurrencyPair::ModEth => Currency::Eth,
            &CurrencyPair::MthBtc => Currency::Btc,
            &CurrencyPair::MthEth => Currency::Eth,
            &CurrencyPair::MtlBtc => Currency::Btc,
            &CurrencyPair::MtlEth => Currency::Eth,
            &CurrencyPair::MtlUsdt => Currency::Usdt,
            &CurrencyPair::NanoBnb => Currency::Bnb,
            &CurrencyPair::NanoBtc => Currency::Btc,
            &CurrencyPair::NanoEth => Currency::Eth,
            &CurrencyPair::NanoUsdt => Currency::Usdt,
            &CurrencyPair::NasBnb => Currency::Bnb,
            &CurrencyPair::NasBtc => Currency::Btc,
            &CurrencyPair::NasEth => Currency::Eth,
            &CurrencyPair::NavBnb => Currency::Bnb,
            &CurrencyPair::NavBtc => Currency::Btc,
            &CurrencyPair::NavEth => Currency::Eth,
            &CurrencyPair::NcashBnb => Currency::Bnb,
            &CurrencyPair::NcashBtc => Currency::Btc,
            &CurrencyPair::NcashEth => Currency::Eth,
            &CurrencyPair::NeblBnb => Currency::Bnb,
            &CurrencyPair::NeblBtc => Currency::Btc,
            &CurrencyPair::NeblEth => Currency::Eth,
            &CurrencyPair::NeoBnb => Currency::Bnb,
            &CurrencyPair::NeoBtc => Currency::Btc,
            &CurrencyPair::NeoEth => Currency::Eth,
            &CurrencyPair::NeoPax => Currency::Pax,
            &CurrencyPair::NeoTusd => Currency::Tusd,
            &CurrencyPair::NeoUsdc => Currency::Usdc,
            &CurrencyPair::NeoUsdt => Currency::Usdt,
            &CurrencyPair::NknBnb => Currency::Bnb,
            &CurrencyPair::NknBtc => Currency::Btc,
            &CurrencyPair::NknUsdt => Currency::Usdt,
            &CurrencyPair::NpxsBtc => Currency::Btc,
            &CurrencyPair::NpxsEth => Currency::Eth,
            &CurrencyPair::NpxsUsdc => Currency::Usdc,
            &CurrencyPair::NpxsUsdt => Currency::Usdt,
            &CurrencyPair::NulsBnb => Currency::Bnb,
            &CurrencyPair::NulsBtc => Currency::Btc,
            &CurrencyPair::NulsEth => Currency::Eth,
            &CurrencyPair::NulsUsdt => Currency::Usdt,
            &CurrencyPair::NxsBnb => Currency::Bnb,
            &CurrencyPair::NxsBtc => Currency::Btc,
            &CurrencyPair::NxsEth => Currency::Eth,
            &CurrencyPair::OaxBtc => Currency::Btc,
            &CurrencyPair::OaxEth => Currency::Eth,
            &CurrencyPair::OmgBnb => Currency::Bnb,
            &CurrencyPair::OmgBtc => Currency::Btc,
            &CurrencyPair::OmgEth => Currency::Eth,
            &CurrencyPair::OmgUsdt => Currency::Usdt,
            &CurrencyPair::OneBnb => Currency::Bnb,
            &CurrencyPair::OneBtc => Currency::Btc,
            &CurrencyPair::OnePax => Currency::Pax,
            &CurrencyPair::OneTusd => Currency::Tusd,
            &CurrencyPair::OneUsdc => Currency::Usdc,
            &CurrencyPair::OneUsdt => Currency::Usdt,
            &CurrencyPair::OngBnb => Currency::Bnb,
            &CurrencyPair::OngBtc => Currency::Btc,
            &CurrencyPair::OngUsdt => Currency::Usdt,
            &CurrencyPair::OntBnb => Currency::Bnb,
            &CurrencyPair::OntBtc => Currency::Btc,
            &CurrencyPair::OntEth => Currency::Eth,
            &CurrencyPair::OntPax => Currency::Pax,
            &CurrencyPair::OntUsdc => Currency::Usdc,
            &CurrencyPair::OntUsdt => Currency::Usdt,
            &CurrencyPair::OstBnb => Currency::Bnb,
            &CurrencyPair::OstBtc => Currency::Btc,
            &CurrencyPair::OstEth => Currency::Eth,
            &CurrencyPair::PaxBnb => Currency::Bnb,
            &CurrencyPair::PaxBtc => Currency::Btc,
            &CurrencyPair::PaxEth => Currency::Eth,
            &CurrencyPair::PaxTusd => Currency::Tusd,
            &CurrencyPair::PaxUsdt => Currency::Usdt,
            &CurrencyPair::PerlBnb => Currency::Bnb,
            &CurrencyPair::PerlBtc => Currency::Btc,
            &CurrencyPair::PerlUsdc => Currency::Usdc,
            &CurrencyPair::PerlUsdt => Currency::Usdt,
            &CurrencyPair::PhbBnb => Currency::Bnb,
            &CurrencyPair::PhbBtc => Currency::Btc,
            &CurrencyPair::PhbPax => Currency::Pax,
            &CurrencyPair::PhbTusd => Currency::Tusd,
            &CurrencyPair::PhbUsdc => Currency::Usdc,
            &CurrencyPair::PhxBnb => Currency::Bnb,
            &CurrencyPair::PhxBtc => Currency::Btc,
            &CurrencyPair::PhxEth => Currency::Eth,
            &CurrencyPair::PivxBnb => Currency::Bnb,
            &CurrencyPair::PivxBtc => Currency::Btc,
            &CurrencyPair::PivxEth => Currency::Eth,
            &CurrencyPair::PoaBnb => Currency::Bnb,
            &CurrencyPair::PoaBtc => Currency::Btc,
            &CurrencyPair::PoaEth => Currency::Eth,
            &CurrencyPair::PoeBtc => Currency::Btc,
            &CurrencyPair::PoeEth => Currency::Eth,
            &CurrencyPair::PolyBnb => Currency::Bnb,
            &CurrencyPair::PolyBtc => Currency::Btc,
            &CurrencyPair::PowrBnb => Currency::Bnb,
            &CurrencyPair::PowrBtc => Currency::Btc,
            &CurrencyPair::PowrEth => Currency::Eth,
            &CurrencyPair::PptBtc => Currency::Btc,
            &CurrencyPair::PptEth => Currency::Eth,
            &CurrencyPair::QkcBtc => Currency::Btc,
            &CurrencyPair::QkcEth => Currency::Eth,
            &CurrencyPair::QlcBnb => Currency::Bnb,
            &CurrencyPair::QlcBtc => Currency::Btc,
            &CurrencyPair::QlcEth => Currency::Eth,
            &CurrencyPair::QspBnb => Currency::Bnb,
            &CurrencyPair::QspBtc => Currency::Btc,
            &CurrencyPair::QspEth => Currency::Eth,
            &CurrencyPair::QtumBnb => Currency::Bnb,
            &CurrencyPair::QtumBtc => Currency::Btc,
            &CurrencyPair::QtumBusd => Currency::Busd,
            &CurrencyPair::QtumEth => Currency::Eth,
            &CurrencyPair::QtumUsdt => Currency::Usdt,
            &CurrencyPair::RcnBnb => Currency::Bnb,
            &CurrencyPair::RcnBtc => Currency::Btc,
            &CurrencyPair::RcnEth => Currency::Eth,
            &CurrencyPair::RdnBnb => Currency::Bnb,
            &CurrencyPair::RdnBtc => Currency::Btc,
            &CurrencyPair::RdnEth => Currency::Eth,
            &CurrencyPair::RenBnb => Currency::Bnb,
            &CurrencyPair::RenBtc => Currency::Btc,
            &CurrencyPair::RenUsdt => Currency::Usdt,
            &CurrencyPair::RepBnb => Currency::Bnb,
            &CurrencyPair::RepBtc => Currency::Btc,
            &CurrencyPair::RepEth => Currency::Eth,
            &CurrencyPair::ReqBtc => Currency::Btc,
            &CurrencyPair::ReqEth => Currency::Eth,
            &CurrencyPair::RlcBnb => Currency::Bnb,
            &CurrencyPair::RlcBtc => Currency::Btc,
            &CurrencyPair::RlcEth => Currency::Eth,
            &CurrencyPair::RlcUsdt => Currency::Usdt,
            &CurrencyPair::RpxBnb => Currency::Bnb,
            &CurrencyPair::RpxBtc => Currency::Btc,
            &CurrencyPair::RpxEth => Currency::Eth,
            &CurrencyPair::RvnBnb => Currency::Bnb,
            &CurrencyPair::RvnBtc => Currency::Btc,
            &CurrencyPair::RvnUsdt => Currency::Usdt,
            &CurrencyPair::SaltBtc => Currency::Btc,
            &CurrencyPair::SaltEth => Currency::Eth,
            &CurrencyPair::ScBnb => Currency::Bnb,
            &CurrencyPair::ScBtc => Currency::Btc,
            &CurrencyPair::ScEth => Currency::Eth,
            &CurrencyPair::SkyBnb => Currency::Bnb,
            &CurrencyPair::SkyBtc => Currency::Btc,
            &CurrencyPair::SkyEth => Currency::Eth,
            &CurrencyPair::SnglsBtc => Currency::Btc,
            &CurrencyPair::SnglsEth => Currency::Eth,
            &CurrencyPair::SnmBtc => Currency::Btc,
            &CurrencyPair::SnmEth => Currency::Eth,
            &CurrencyPair::SntBtc => Currency::Btc,
            &CurrencyPair::SntEth => Currency::Eth,
            &CurrencyPair::SteemBnb => Currency::Bnb,
            &CurrencyPair::SteemBtc => Currency::Btc,
            &CurrencyPair::SteemEth => Currency::Eth,
            &CurrencyPair::StorjBtc => Currency::Btc,
            &CurrencyPair::StorjEth => Currency::Eth,
            &CurrencyPair::StormBnb => Currency::Bnb,
            &CurrencyPair::StormBtc => Currency::Btc,
            &CurrencyPair::StormEth => Currency::Eth,
            &CurrencyPair::StormUsdt => Currency::Usdt,
            &CurrencyPair::StratBtc => Currency::Btc,
            &CurrencyPair::StratEth => Currency::Eth,
            &CurrencyPair::StxBnb => Currency::Bnb,
            &CurrencyPair::StxBtc => Currency::Btc,
            &CurrencyPair::StxUsdt => Currency::Usdt,
            &CurrencyPair::SubBtc => Currency::Btc,
            &CurrencyPair::SubEth => Currency::Eth,
            &CurrencyPair::SysBnb => Currency::Bnb,
            &CurrencyPair::SysBtc => Currency::Btc,
            &CurrencyPair::SysEth => Currency::Eth,
            &CurrencyPair::TfuelBnb => Currency::Bnb,
            &CurrencyPair::TfuelBtc => Currency::Btc,
            &CurrencyPair::TfuelPax => Currency::Pax,
            &CurrencyPair::TfuelTusd => Currency::Tusd,
            &CurrencyPair::TfuelUsdc => Currency::Usdc,
            &CurrencyPair::TfuelUsdt => Currency::Usdt,
            &CurrencyPair::ThetaBnb => Currency::Bnb,
            &CurrencyPair::ThetaBtc => Currency::Btc,
            &CurrencyPair::ThetaEth => Currency::Eth,
            &CurrencyPair::ThetaUsdt => Currency::Usdt,
            &CurrencyPair::TnbBtc => Currency::Btc,
            &CurrencyPair::TnbEth => Currency::Eth,
            &CurrencyPair::TntBtc => Currency::Btc,
            &CurrencyPair::TntEth => Currency::Eth,
            &CurrencyPair::TomoBnb => Currency::Bnb,
            &CurrencyPair::TomoBtc => Currency::Btc,
            &CurrencyPair::TomoUsdc => Currency::Usdc,
            &CurrencyPair::TomoUsdt => Currency::Usdt,
            &CurrencyPair::TrigBnb => Currency::Bnb,
            &CurrencyPair::TrigBtc => Currency::Btc,
            &CurrencyPair::TrigEth => Currency::Eth,
            &CurrencyPair::TroyBnb => Currency::Bnb,
            &CurrencyPair::TroyBtc => Currency::Btc,
            &CurrencyPair::TroyUsdt => Currency::Usdt,
            &CurrencyPair::TrxBnb => Currency::Bnb,
            &CurrencyPair::TrxBtc => Currency::Btc,
            &CurrencyPair::TrxBusd => Currency::Busd,
            &CurrencyPair::TrxEth => Currency::Eth,
            &CurrencyPair::TrxPax => Currency::Pax,
            &CurrencyPair::TrxTusd => Currency::Tusd,
            &CurrencyPair::TrxUsdc => Currency::Usdc,
            &CurrencyPair::TrxUsdt => Currency::Usdt,
            &CurrencyPair::TrxXrp => Currency::Xrp,
            &CurrencyPair::TusdbTusd => Currency::Tusd,
            &CurrencyPair::TusdBnb => Currency::Bnb,
            &CurrencyPair::TusdBtc => Currency::Btc,
            &CurrencyPair::TusdEth => Currency::Eth,
            &CurrencyPair::TusdUsdt => Currency::Usdt,
            &CurrencyPair::UsdcBnb => Currency::Bnb,
            &CurrencyPair::UsdcDash => Currency::Dash,
            &CurrencyPair::UsdcGrin => Currency::Grin,
            &CurrencyPair::UsdcPax => Currency::Pax,
            &CurrencyPair::UsdcStr => Currency::Str,
            &CurrencyPair::UsdcTusd => Currency::Tusd,
            &CurrencyPair::UsdcUsdt => Currency::Usdt,
            &CurrencyPair::UsdcXmr => Currency::Xmr,
            &CurrencyPair::UsdsbUsds => Currency::Usds,
            &CurrencyPair::UsdsbUsdt => Currency::Usdt,
            &CurrencyPair::UsdsPax => Currency::Pax,
            &CurrencyPair::UsdsTusd => Currency::Tusd,
            &CurrencyPair::UsdsUsdc => Currency::Usdc,
            &CurrencyPair::UsdsUsdt => Currency::Usdt,
            &CurrencyPair::UsdtDgb => Currency::Dgb,
            &CurrencyPair::UsdtGnt => Currency::Gnt,
            &CurrencyPair::UsdtGrin => Currency::Grin,
            &CurrencyPair::UsdtLsk => Currency::Lsk,
            &CurrencyPair::UsdtMana => Currency::Mana,
            &CurrencyPair::UsdtNxt => Currency::Nxt,
            &CurrencyPair::UsdtRep => Currency::Rep,
            &CurrencyPair::UsdtRub => Currency::Rub,
            &CurrencyPair::UsdtSc => Currency::Sc,
            &CurrencyPair::UsdtStr => Currency::Str,
            &CurrencyPair::UsdtTry => Currency::Try,
            &CurrencyPair::VenBnb => Currency::Bnb,
            &CurrencyPair::VenBtc => Currency::Btc,
            &CurrencyPair::VenEth => Currency::Eth,
            &CurrencyPair::VenUsdt => Currency::Usdt,
            &CurrencyPair::VetBnb => Currency::Bnb,
            &CurrencyPair::VetBtc => Currency::Btc,
            &CurrencyPair::VetBusd => Currency::Busd,
            &CurrencyPair::VetEth => Currency::Eth,
            &CurrencyPair::VetUsdt => Currency::Usdt,
            &CurrencyPair::ViaBnb => Currency::Bnb,
            &CurrencyPair::ViaBtc => Currency::Btc,
            &CurrencyPair::ViaEth => Currency::Eth,
            &CurrencyPair::VibeBtc => Currency::Btc,
            &CurrencyPair::VibeEth => Currency::Eth,
            &CurrencyPair::VibBtc => Currency::Btc,
            &CurrencyPair::VibEth => Currency::Eth,
            &CurrencyPair::ViteBnb => Currency::Bnb,
            &CurrencyPair::ViteBtc => Currency::Btc,
            &CurrencyPair::ViteUsdt => Currency::Usdt,
            &CurrencyPair::WabiBnb => Currency::Bnb,
            &CurrencyPair::WabiBtc => Currency::Btc,
            &CurrencyPair::WabiEth => Currency::Eth,
            &CurrencyPair::WanBnb => Currency::Bnb,
            &CurrencyPair::WanBtc => Currency::Btc,
            &CurrencyPair::WanEth => Currency::Eth,
            &CurrencyPair::WanUsdt => Currency::Usdt,
            &CurrencyPair::WavesBnb => Currency::Bnb,
            &CurrencyPair::WavesBtc => Currency::Btc,
            &CurrencyPair::WavesEth => Currency::Eth,
            &CurrencyPair::WavesPax => Currency::Pax,
            &CurrencyPair::WavesTusd => Currency::Tusd,
            &CurrencyPair::WavesUsdc => Currency::Usdc,
            &CurrencyPair::WavesUsdt => Currency::Usdt,
            &CurrencyPair::WingsBtc => Currency::Btc,
            &CurrencyPair::WingsEth => Currency::Eth,
            &CurrencyPair::WinBnb => Currency::Bnb,
            &CurrencyPair::WinBtc => Currency::Btc,
            &CurrencyPair::WinTrx => Currency::Trx,
            &CurrencyPair::WinUsdc => Currency::Usdc,
            &CurrencyPair::WinUsdt => Currency::Usdt,
            &CurrencyPair::WprBtc => Currency::Btc,
            &CurrencyPair::WprEth => Currency::Eth,
            &CurrencyPair::WtcBnb => Currency::Bnb,
            &CurrencyPair::WtcBtc => Currency::Btc,
            &CurrencyPair::WtcEth => Currency::Eth,
            &CurrencyPair::XemBnb => Currency::Bnb,
            &CurrencyPair::XemBtc => Currency::Btc,
            &CurrencyPair::XemEth => Currency::Eth,
            &CurrencyPair::XlmBnb => Currency::Bnb,
            &CurrencyPair::XlmBtc => Currency::Btc,
            &CurrencyPair::XlmBusd => Currency::Busd,
            &CurrencyPair::XlmEth => Currency::Eth,
            &CurrencyPair::XlmPax => Currency::Pax,
            &CurrencyPair::XlmTusd => Currency::Tusd,
            &CurrencyPair::XlmUsdc => Currency::Usdc,
            &CurrencyPair::XlmUsdt => Currency::Usdt,
            &CurrencyPair::XmrBnb => Currency::Bnb,
            &CurrencyPair::XmrBtc => Currency::Btc,
            &CurrencyPair::XmrEth => Currency::Eth,
            &CurrencyPair::XmrUsdt => Currency::Usdt,
            &CurrencyPair::XrpBnb => Currency::Bnb,
            &CurrencyPair::XrpBtc => Currency::Btc,
            &CurrencyPair::XrpBusd => Currency::Busd,
            &CurrencyPair::XrpEth => Currency::Eth,
            &CurrencyPair::XrpPax => Currency::Pax,
            &CurrencyPair::XrpRub => Currency::Rub,
            &CurrencyPair::XrpTry => Currency::Try,
            &CurrencyPair::XrpTusd => Currency::Tusd,
            &CurrencyPair::XrpUsdc => Currency::Usdc,
            &CurrencyPair::XrpUsdt => Currency::Usdt,
            &CurrencyPair::XtzBnb => Currency::Bnb,
            &CurrencyPair::XtzBtc => Currency::Btc,
            &CurrencyPair::XtzUsdt => Currency::Usdt,
            &CurrencyPair::XvgBtc => Currency::Btc,
            &CurrencyPair::XvgEth => Currency::Eth,
            &CurrencyPair::XzcBnb => Currency::Bnb,
            &CurrencyPair::XzcBtc => Currency::Btc,
            &CurrencyPair::XzcEth => Currency::Eth,
            &CurrencyPair::XzcXrp => Currency::Xrp,
            &CurrencyPair::YoyoBnb => Currency::Bnb,
            &CurrencyPair::YoyoBtc => Currency::Btc,
            &CurrencyPair::YoyoEth => Currency::Eth,
            &CurrencyPair::ZecBnb => Currency::Bnb,
            &CurrencyPair::ZecBtc => Currency::Btc,
            &CurrencyPair::ZecEth => Currency::Eth,
            &CurrencyPair::ZecPax => Currency::Pax,
            &CurrencyPair::ZecTusd => Currency::Tusd,
            &CurrencyPair::ZecUsdc => Currency::Usdc,
            &CurrencyPair::ZecUsdt => Currency::Usdt,
            &CurrencyPair::ZenBnb => Currency::Bnb,
            &CurrencyPair::ZenBtc => Currency::Btc,
            &CurrencyPair::ZenEth => Currency::Eth,
            &CurrencyPair::ZilBnb => Currency::Bnb,
            &CurrencyPair::ZilBtc => Currency::Btc,
            &CurrencyPair::ZilEth => Currency::Eth,
            &CurrencyPair::ZilUsdt => Currency::Usdt,
            &CurrencyPair::ZrxBnb => Currency::Bnb,
            &CurrencyPair::ZrxBtc => Currency::Btc,
            &CurrencyPair::ZrxEth => Currency::Eth,
            &CurrencyPair::ZrxUsdt => Currency::Usdt,
        }
    }
}

impl FromStr for CurrencyPair {
    type Err = Error;

    fn from_str(pair: &str) -> Result<Self, Self::Err> {
        match pair {
            "ADA_BNB" => Ok(CurrencyPair::AdaBnb),
            "ADA_BTC" => Ok(CurrencyPair::AdaBtc),
            "ADA_BUSD" => Ok(CurrencyPair::AdaBusd),
            "ADA_ETH" => Ok(CurrencyPair::AdaEth),
            "ADA_PAX" => Ok(CurrencyPair::AdaPax),
            "ADA_TUSD" => Ok(CurrencyPair::AdaTusd),
            "ADA_USDC" => Ok(CurrencyPair::AdaUsdc),
            "ADA_USDT" => Ok(CurrencyPair::AdaUsdt),
            "ADX_BNB" => Ok(CurrencyPair::AdxBnb),
            "ADX_BTC" => Ok(CurrencyPair::AdxBtc),
            "ADX_ETH" => Ok(CurrencyPair::AdxEth),
            "AE_BNB" => Ok(CurrencyPair::AeBnb),
            "AE_BTC" => Ok(CurrencyPair::AeBtc),
            "AE_ETH" => Ok(CurrencyPair::AeEth),
            "AGI_BNB" => Ok(CurrencyPair::AgiBnb),
            "AGI_BTC" => Ok(CurrencyPair::AgiBtc),
            "AGI_ETH" => Ok(CurrencyPair::AgiEth),
            "AION_BNB" => Ok(CurrencyPair::AionBnb),
            "AION_BTC" => Ok(CurrencyPair::AionBtc),
            "AION_ETH" => Ok(CurrencyPair::AionEth),
            "ALGO_BNB" => Ok(CurrencyPair::AlgoBnb),
            "ALGO_BTC" => Ok(CurrencyPair::AlgoBtc),
            "ALGO_PAX" => Ok(CurrencyPair::AlgoPax),
            "ALGO_TUSD" => Ok(CurrencyPair::AlgoTusd),
            "ALGO_USDC" => Ok(CurrencyPair::AlgoUsdc),
            "ALGO_USDT" => Ok(CurrencyPair::AlgoUsdt),
            "AMB_BNB" => Ok(CurrencyPair::AmbBnb),
            "AMB_BTC" => Ok(CurrencyPair::AmbBtc),
            "AMB_ETH" => Ok(CurrencyPair::AmbEth),
            "ANKR_BNB" => Ok(CurrencyPair::AnkrBnb),
            "ANKR_BTC" => Ok(CurrencyPair::AnkrBtc),
            "ANKR_PAX" => Ok(CurrencyPair::AnkrPax),
            "ANKR_TUSD" => Ok(CurrencyPair::AnkrTusd),
            "ANKR_USDC" => Ok(CurrencyPair::AnkrUsdc),
            "ANKR_USDT" => Ok(CurrencyPair::AnkrUsdt),
            "APPC_BNB" => Ok(CurrencyPair::AppcBnb),
            "APPC_BTC" => Ok(CurrencyPair::AppcBtc),
            "APPC_ETH" => Ok(CurrencyPair::AppcEth),
            "ARDR_BNB" => Ok(CurrencyPair::ArdrBnb),
            "ARDR_BTC" => Ok(CurrencyPair::ArdrBtc),
            "ARDR_ETH" => Ok(CurrencyPair::ArdrEth),
            "ARK_BTC" => Ok(CurrencyPair::ArkBtc),
            "ARK_ETH" => Ok(CurrencyPair::ArkEth),
            "ARN_BTC" => Ok(CurrencyPair::ArnBtc),
            "ARN_ETH" => Ok(CurrencyPair::ArnEth),
            "ARPA_BNB" => Ok(CurrencyPair::ArpaBnb),
            "ARPA_BTC" => Ok(CurrencyPair::ArpaBtc),
            "ARPA_USDT" => Ok(CurrencyPair::ArpaUsdt),
            "AST_BTC" => Ok(CurrencyPair::AstBtc),
            "AST_ETH" => Ok(CurrencyPair::AstEth),
            "ATOM_BNB" => Ok(CurrencyPair::AtomBnb),
            "ATOM_BTC" => Ok(CurrencyPair::AtomBtc),
            "ATOM_PAX" => Ok(CurrencyPair::AtomPax),
            "ATOM_TUSD" => Ok(CurrencyPair::AtomTusd),
            "ATOM_USDC" => Ok(CurrencyPair::AtomUsdc),
            "ATOM_USDT" => Ok(CurrencyPair::AtomUsdt),
            "BAND_BNB" => Ok(CurrencyPair::BandBnb),
            "BAND_BTC" => Ok(CurrencyPair::BandBtc),
            "BAND_USDT" => Ok(CurrencyPair::BandUsdt),
            "BAT_BNB" => Ok(CurrencyPair::BatBnb),
            "BAT_BTC" => Ok(CurrencyPair::BatBtc),
            "BAT_ETH" => Ok(CurrencyPair::BatEth),
            "BAT_PAX" => Ok(CurrencyPair::BatPax),
            "BAT_TUSD" => Ok(CurrencyPair::BatTusd),
            "BAT_USDC" => Ok(CurrencyPair::BatUsdc),
            "BAT_USDT" => Ok(CurrencyPair::BatUsdt),
            "BCC_BNB" => Ok(CurrencyPair::BccBnb),
            "BCC_BTC" => Ok(CurrencyPair::BccBtc),
            "BCC_ETH" => Ok(CurrencyPair::BccEth),
            "BCC_USDT" => Ok(CurrencyPair::BccUsdt),
            "BCD_BTC" => Ok(CurrencyPair::BcdBtc),
            "BCD_ETH" => Ok(CurrencyPair::BcdEth),
            "BCHABC_BTC" => Ok(CurrencyPair::BchabcBtc),
            "BCHABC_BUSD" => Ok(CurrencyPair::BchabcBusd),
            "BCHABC_PAX" => Ok(CurrencyPair::BchabcPax),
            "BCHABC_TUSD" => Ok(CurrencyPair::BchabcTusd),
            "BCHABC_USDC" => Ok(CurrencyPair::BchabcUsdc),
            "BCHABC_USDT" => Ok(CurrencyPair::BchabcUsdt),
            "BCHSV_BTC" => Ok(CurrencyPair::BchsvBtc),
            "BCHSV_PAX" => Ok(CurrencyPair::BchsvPax),
            "BCHSV_TUSD" => Ok(CurrencyPair::BchsvTusd),
            "BCHSV_USDC" => Ok(CurrencyPair::BchsvUsdc),
            "BCHSV_USDT" => Ok(CurrencyPair::BchsvUsdt),
            "BCH_BNB" => Ok(CurrencyPair::BchBnb),
            "BCH_BTC" => Ok(CurrencyPair::BchBtc),
            "BCH_BUSD" => Ok(CurrencyPair::BchBusd),
            "BCH_PAX" => Ok(CurrencyPair::BchPax),
            "BCH_TUSD" => Ok(CurrencyPair::BchTusd),
            "BCH_USDC" => Ok(CurrencyPair::BchUsdc),
            "BCH_USDT" => Ok(CurrencyPair::BchUsdt),
            "BCN_BNB" => Ok(CurrencyPair::BcnBnb),
            "BCN_BTC" => Ok(CurrencyPair::BcnBtc),
            "BCN_ETH" => Ok(CurrencyPair::BcnEth),
            "BCPT_BNB" => Ok(CurrencyPair::BcptBnb),
            "BCPT_BTC" => Ok(CurrencyPair::BcptBtc),
            "BCPT_ETH" => Ok(CurrencyPair::BcptEth),
            "BCPT_PAX" => Ok(CurrencyPair::BcptPax),
            "BCPT_TUSD" => Ok(CurrencyPair::BcptTusd),
            "BCPT_USDC" => Ok(CurrencyPair::BcptUsdc),
            "BEAM_BNB" => Ok(CurrencyPair::BeamBnb),
            "BEAM_BTC" => Ok(CurrencyPair::BeamBtc),
            "BEAM_USDT" => Ok(CurrencyPair::BeamUsdt),
            "BGBP_USDC" => Ok(CurrencyPair::BgbpUsdc),
            "BLZ_BNB" => Ok(CurrencyPair::BlzBnb),
            "BLZ_BTC" => Ok(CurrencyPair::BlzBtc),
            "BLZ_ETH" => Ok(CurrencyPair::BlzEth),
            "BNB_BTC" => Ok(CurrencyPair::BnbBtc),
            "BNB_BUSD" => Ok(CurrencyPair::BnbBusd),
            "BNB_ETH" => Ok(CurrencyPair::BnbEth),
            "BNB_NGN" => Ok(CurrencyPair::BnbNgn),
            "BNB_PAX" => Ok(CurrencyPair::BnbPax),
            "BNB_RUB" => Ok(CurrencyPair::BnbRub),
            "BNB_TRY" => Ok(CurrencyPair::BnbTry),
            "BNB_TUSD" => Ok(CurrencyPair::BnbTusd),
            "BNB_USDC" => Ok(CurrencyPair::BnbUsdc),
            "BNB_USDS" => Ok(CurrencyPair::BnbUsds),
            "BNB_USDT" => Ok(CurrencyPair::BnbUsdt),
            "BNT_BTC" => Ok(CurrencyPair::BntBtc),
            "BNT_ETH" => Ok(CurrencyPair::BntEth),
            "BQX_BTC" => Ok(CurrencyPair::BqxBtc),
            "BQX_ETH" => Ok(CurrencyPair::BqxEth),
            "BRD_BNB" => Ok(CurrencyPair::BrdBnb),
            "BRD_BTC" => Ok(CurrencyPair::BrdBtc),
            "BRD_ETH" => Ok(CurrencyPair::BrdEth),
            "BTCB_BTC" => Ok(CurrencyPair::BtcbBtc),
            "BTC_BUSD" => Ok(CurrencyPair::BtcBusd),
            "BTC_DGB" => Ok(CurrencyPair::BtcDgb),
            "BTC_FCT" => Ok(CurrencyPair::BtcFct),
            "BTC_FOAM" => Ok(CurrencyPair::BtcFoam),
            "BTC_GRIN" => Ok(CurrencyPair::BtcGrin),
            "BTC_LPT" => Ok(CurrencyPair::BtcLpt),
            "BTC_MAID" => Ok(CurrencyPair::BtcMaid),
            "BTC_NGN" => Ok(CurrencyPair::BtcNgn),
            "BTC_NMR" => Ok(CurrencyPair::BtcNmr),
            "BTC_NXT" => Ok(CurrencyPair::BtcNxt),
            "BTC_OMNI" => Ok(CurrencyPair::BtcOmni),
            "BTC_PAX" => Ok(CurrencyPair::BtcPax),
            "BTC_RUB" => Ok(CurrencyPair::BtcRub),
            "BTC_STR" => Ok(CurrencyPair::BtcStr),
            "BTC_TRY" => Ok(CurrencyPair::BtcTry),
            "BTC_TUSD" => Ok(CurrencyPair::BtcTusd),
            "BTC_USDC" => Ok(CurrencyPair::BtcUsdc),
            "BTC_USDS" => Ok(CurrencyPair::BtcUsds),
            "BTC_USDT" => Ok(CurrencyPair::BtcUsdt),
            "BTC_VTC" => Ok(CurrencyPair::BtcVtc),
            "BTC_XPM" => Ok(CurrencyPair::BtcXpm),
            "BTG_BTC" => Ok(CurrencyPair::BtgBtc),
            "BTG_ETH" => Ok(CurrencyPair::BtgEth),
            "BTS_BNB" => Ok(CurrencyPair::BtsBnb),
            "BTS_BTC" => Ok(CurrencyPair::BtsBtc),
            "BTS_ETH" => Ok(CurrencyPair::BtsEth),
            "BTT_BNB" => Ok(CurrencyPair::BttBnb),
            "BTT_BTC" => Ok(CurrencyPair::BttBtc),
            "BTT_PAX" => Ok(CurrencyPair::BttPax),
            "BTT_TRX" => Ok(CurrencyPair::BttTrx),
            "BTT_TUSD" => Ok(CurrencyPair::BttTusd),
            "BTT_USDC" => Ok(CurrencyPair::BttUsdc),
            "BTT_USDT" => Ok(CurrencyPair::BttUsdt),
            "BUSD_NGN" => Ok(CurrencyPair::BusdNgn),
            "BUSD_RUB" => Ok(CurrencyPair::BusdRub),
            "BUSD_TRY" => Ok(CurrencyPair::BusdTry),
            "BUSD_USDT" => Ok(CurrencyPair::BusdUsdt),
            "CDT_BTC" => Ok(CurrencyPair::CdtBtc),
            "CDT_ETH" => Ok(CurrencyPair::CdtEth),
            "CELR_BNB" => Ok(CurrencyPair::CelrBnb),
            "CELR_BTC" => Ok(CurrencyPair::CelrBtc),
            "CELR_USDT" => Ok(CurrencyPair::CelrUsdt),
            "CHAT_BTC" => Ok(CurrencyPair::ChatBtc),
            "CHAT_ETH" => Ok(CurrencyPair::ChatEth),
            "CHZ_BNB" => Ok(CurrencyPair::ChzBnb),
            "CHZ_BTC" => Ok(CurrencyPair::ChzBtc),
            "CHZ_USDT" => Ok(CurrencyPair::ChzUsdt),
            "CLOAK_BTC" => Ok(CurrencyPair::CloakBtc),
            "CLOAK_ETH" => Ok(CurrencyPair::CloakEth),
            "CMT_BNB" => Ok(CurrencyPair::CmtBnb),
            "CMT_BTC" => Ok(CurrencyPair::CmtBtc),
            "CMT_ETH" => Ok(CurrencyPair::CmtEth),
            "CND_BNB" => Ok(CurrencyPair::CndBnb),
            "CND_BTC" => Ok(CurrencyPair::CndBtc),
            "CND_ETH" => Ok(CurrencyPair::CndEth),
            "COCOS_BNB" => Ok(CurrencyPair::CocosBnb),
            "COCOS_BTC" => Ok(CurrencyPair::CocosBtc),
            "COCOS_USDT" => Ok(CurrencyPair::CocosUsdt),
            "COS_BNB" => Ok(CurrencyPair::CosBnb),
            "COS_BTC" => Ok(CurrencyPair::CosBtc),
            "COS_USDT" => Ok(CurrencyPair::CosUsdt),
            "CTXC_BNB" => Ok(CurrencyPair::CtxcBnb),
            "CTXC_BTC" => Ok(CurrencyPair::CtxcBtc),
            "CTXC_USDT" => Ok(CurrencyPair::CtxcUsdt),
            "CVC_BNB" => Ok(CurrencyPair::CvcBnb),
            "CVC_BTC" => Ok(CurrencyPair::CvcBtc),
            "CVC_ETH" => Ok(CurrencyPair::CvcEth),
            "CVC_USDT" => Ok(CurrencyPair::CvcUsdt),
            "DASH_BNB" => Ok(CurrencyPair::DashBnb),
            "DASH_BTC" => Ok(CurrencyPair::DashBtc),
            "DASH_ETH" => Ok(CurrencyPair::DashEth),
            "DASH_USDT" => Ok(CurrencyPair::DashUsdt),
            "DATA_BTC" => Ok(CurrencyPair::DataBtc),
            "DATA_ETH" => Ok(CurrencyPair::DataEth),
            "DCR_BNB" => Ok(CurrencyPair::DcrBnb),
            "DCR_BTC" => Ok(CurrencyPair::DcrBtc),
            "DENT_BTC" => Ok(CurrencyPair::DentBtc),
            "DENT_ETH" => Ok(CurrencyPair::DentEth),
            "DENT_USDT" => Ok(CurrencyPair::DentUsdt),
            "DGD_BTC" => Ok(CurrencyPair::DgdBtc),
            "DGD_ETH" => Ok(CurrencyPair::DgdEth),
            "DLT_BNB" => Ok(CurrencyPair::DltBnb),
            "DLT_BTC" => Ok(CurrencyPair::DltBtc),
            "DLT_ETH" => Ok(CurrencyPair::DltEth),
            "DNT_BTC" => Ok(CurrencyPair::DntBtc),
            "DNT_ETH" => Ok(CurrencyPair::DntEth),
            "DOCK_BTC" => Ok(CurrencyPair::DockBtc),
            "DOCK_ETH" => Ok(CurrencyPair::DockEth),
            "DOCK_USDT" => Ok(CurrencyPair::DockUsdt),
            "DOGE_BNB" => Ok(CurrencyPair::DogeBnb),
            "DOGE_BTC" => Ok(CurrencyPair::DogeBtc),
            "DOGE_PAX" => Ok(CurrencyPair::DogePax),
            "DOGE_USDC" => Ok(CurrencyPair::DogeUsdc),
            "DOGE_USDT" => Ok(CurrencyPair::DogeUsdt),
            "DUSK_BNB" => Ok(CurrencyPair::DuskBnb),
            "DUSK_BTC" => Ok(CurrencyPair::DuskBtc),
            "DUSK_PAX" => Ok(CurrencyPair::DuskPax),
            "DUSK_USDC" => Ok(CurrencyPair::DuskUsdc),
            "DUSK_USDT" => Ok(CurrencyPair::DuskUsdt),
            "EDO_BTC" => Ok(CurrencyPair::EdoBtc),
            "EDO_ETH" => Ok(CurrencyPair::EdoEth),
            "ELF_BTC" => Ok(CurrencyPair::ElfBtc),
            "ELF_ETH" => Ok(CurrencyPair::ElfEth),
            "ENG_BTC" => Ok(CurrencyPair::EngBtc),
            "ENG_ETH" => Ok(CurrencyPair::EngEth),
            "ENJ_BNB" => Ok(CurrencyPair::EnjBnb),
            "ENJ_BTC" => Ok(CurrencyPair::EnjBtc),
            "ENJ_ETH" => Ok(CurrencyPair::EnjEth),
            "ENJ_USDT" => Ok(CurrencyPair::EnjUsdt),
            "EOS_BNB" => Ok(CurrencyPair::EosBnb),
            "EOS_BTC" => Ok(CurrencyPair::EosBtc),
            "EOS_BUSD" => Ok(CurrencyPair::EosBusd),
            "EOS_ETH" => Ok(CurrencyPair::EosEth),
            "EOS_PAX" => Ok(CurrencyPair::EosPax),
            "EOS_TUSD" => Ok(CurrencyPair::EosTusd),
            "EOS_USDC" => Ok(CurrencyPair::EosUsdc),
            "EOS_USDT" => Ok(CurrencyPair::EosUsdt),
            "ERD_BNB" => Ok(CurrencyPair::ErdBnb),
            "ERD_BTC" => Ok(CurrencyPair::ErdBtc),
            "ERD_PAX" => Ok(CurrencyPair::ErdPax),
            "ERD_USDC" => Ok(CurrencyPair::ErdUsdc),
            "ERD_USDT" => Ok(CurrencyPair::ErdUsdt),
            "ETC_BNB" => Ok(CurrencyPair::EtcBnb),
            "ETC_BTC" => Ok(CurrencyPair::EtcBtc),
            "ETC_BUSD" => Ok(CurrencyPair::EtcBusd),
            "ETC_ETH" => Ok(CurrencyPair::EtcEth),
            "ETC_PAX" => Ok(CurrencyPair::EtcPax),
            "ETC_TUSD" => Ok(CurrencyPair::EtcTusd),
            "ETC_USDC" => Ok(CurrencyPair::EtcUsdc),
            "ETC_USDT" => Ok(CurrencyPair::EtcUsdt),
            "ETH_BTC" => Ok(CurrencyPair::EthBtc),
            "ETH_BUSD" => Ok(CurrencyPair::EthBusd),
            "ETH_PAX" => Ok(CurrencyPair::EthPax),
            "ETH_RUB" => Ok(CurrencyPair::EthRub),
            "ETH_TRY" => Ok(CurrencyPair::EthTry),
            "ETH_TUSD" => Ok(CurrencyPair::EthTusd),
            "ETH_USDC" => Ok(CurrencyPair::EthUsdc),
            "ETH_USDT" => Ok(CurrencyPair::EthUsdt),
            "EVX_BTC" => Ok(CurrencyPair::EvxBtc),
            "EVX_ETH" => Ok(CurrencyPair::EvxEth),
            "FET_BNB" => Ok(CurrencyPair::FetBnb),
            "FET_BTC" => Ok(CurrencyPair::FetBtc),
            "FET_USDT" => Ok(CurrencyPair::FetUsdt),
            "FTM_BNB" => Ok(CurrencyPair::FtmBnb),
            "FTM_BTC" => Ok(CurrencyPair::FtmBtc),
            "FTM_PAX" => Ok(CurrencyPair::FtmPax),
            "FTM_TUSD" => Ok(CurrencyPair::FtmTusd),
            "FTM_USDC" => Ok(CurrencyPair::FtmUsdc),
            "FTM_USDT" => Ok(CurrencyPair::FtmUsdt),
            "FTT_BNB" => Ok(CurrencyPair::FttBnb),
            "FTT_BTC" => Ok(CurrencyPair::FttBtc),
            "FTT_USDT" => Ok(CurrencyPair::FttUsdt),
            "FUEL_BTC" => Ok(CurrencyPair::FuelBtc),
            "FUEL_ETH" => Ok(CurrencyPair::FuelEth),
            "FUN_BTC" => Ok(CurrencyPair::FunBtc),
            "FUN_ETH" => Ok(CurrencyPair::FunEth),
            "FUN_USDT" => Ok(CurrencyPair::FunUsdt),
            "GAS_BTC" => Ok(CurrencyPair::GasBtc),
            "GNT_BNB" => Ok(CurrencyPair::GntBnb),
            "GNT_BTC" => Ok(CurrencyPair::GntBtc),
            "GNT_ETH" => Ok(CurrencyPair::GntEth),
            "GO_BNB" => Ok(CurrencyPair::GoBnb),
            "GO_BTC" => Ok(CurrencyPair::GoBtc),
            "GRS_BTC" => Ok(CurrencyPair::GrsBtc),
            "GRS_ETH" => Ok(CurrencyPair::GrsEth),
            "GTO_BNB" => Ok(CurrencyPair::GtoBnb),
            "GTO_BTC" => Ok(CurrencyPair::GtoBtc),
            "GTO_ETH" => Ok(CurrencyPair::GtoEth),
            "GTO_PAX" => Ok(CurrencyPair::GtoPax),
            "GTO_TUSD" => Ok(CurrencyPair::GtoTusd),
            "GTO_USDC" => Ok(CurrencyPair::GtoUsdc),
            "GTO_USDT" => Ok(CurrencyPair::GtoUsdt),
            "GVT_BTC" => Ok(CurrencyPair::GvtBtc),
            "GVT_ETH" => Ok(CurrencyPair::GvtEth),
            "GXS_BTC" => Ok(CurrencyPair::GxsBtc),
            "GXS_ETH" => Ok(CurrencyPair::GxsEth),
            "HBAR_BNB" => Ok(CurrencyPair::HbarBnb),
            "HBAR_BTC" => Ok(CurrencyPair::HbarBtc),
            "HBAR_USDT" => Ok(CurrencyPair::HbarUsdt),
            "HC_BTC" => Ok(CurrencyPair::HcBtc),
            "HC_ETH" => Ok(CurrencyPair::HcEth),
            "HC_USDT" => Ok(CurrencyPair::HcUsdt),
            "HOT_BNB" => Ok(CurrencyPair::HotBnb),
            "HOT_BTC" => Ok(CurrencyPair::HotBtc),
            "HOT_ETH" => Ok(CurrencyPair::HotEth),
            "HOT_USDT" => Ok(CurrencyPair::HotUsdt),
            "HSR_BTC" => Ok(CurrencyPair::HsrBtc),
            "HSR_ETH" => Ok(CurrencyPair::HsrEth),
            "ICN_BTC" => Ok(CurrencyPair::IcnBtc),
            "ICN_ETH" => Ok(CurrencyPair::IcnEth),
            "ICX_BNB" => Ok(CurrencyPair::IcxBnb),
            "ICX_BTC" => Ok(CurrencyPair::IcxBtc),
            "ICX_ETH" => Ok(CurrencyPair::IcxEth),
            "ICX_USDT" => Ok(CurrencyPair::IcxUsdt),
            "INS_BTC" => Ok(CurrencyPair::InsBtc),
            "INS_ETH" => Ok(CurrencyPair::InsEth),
            "IOST_BNB" => Ok(CurrencyPair::IostBnb),
            "IOST_BTC" => Ok(CurrencyPair::IostBtc),
            "IOST_ETH" => Ok(CurrencyPair::IostEth),
            "IOST_USDT" => Ok(CurrencyPair::IostUsdt),
            "IOTA_BNB" => Ok(CurrencyPair::IotaBnb),
            "IOTA_BTC" => Ok(CurrencyPair::IotaBtc),
            "IOTA_ETH" => Ok(CurrencyPair::IotaEth),
            "IOTA_USDT" => Ok(CurrencyPair::IotaUsdt),
            "IOTX_BTC" => Ok(CurrencyPair::IotxBtc),
            "IOTX_ETH" => Ok(CurrencyPair::IotxEth),
            "IOTX_USDT" => Ok(CurrencyPair::IotxUsdt),
            "KAVA_BNB" => Ok(CurrencyPair::KavaBnb),
            "KAVA_BTC" => Ok(CurrencyPair::KavaBtc),
            "KAVA_USDT" => Ok(CurrencyPair::KavaUsdt),
            "KEY_BTC" => Ok(CurrencyPair::KeyBtc),
            "KEY_ETH" => Ok(CurrencyPair::KeyEth),
            "KEY_USDT" => Ok(CurrencyPair::KeyUsdt),
            "KMD_BTC" => Ok(CurrencyPair::KmdBtc),
            "KMD_ETH" => Ok(CurrencyPair::KmdEth),
            "KNC_BTC" => Ok(CurrencyPair::KncBtc),
            "KNC_ETH" => Ok(CurrencyPair::KncEth),
            "LEND_BTC" => Ok(CurrencyPair::LendBtc),
            "LEND_ETH" => Ok(CurrencyPair::LendEth),
            "LINK_BTC" => Ok(CurrencyPair::LinkBtc),
            "LINK_BUSD" => Ok(CurrencyPair::LinkBusd),
            "LINK_ETH" => Ok(CurrencyPair::LinkEth),
            "LINK_PAX" => Ok(CurrencyPair::LinkPax),
            "LINK_TUSD" => Ok(CurrencyPair::LinkTusd),
            "LINK_USDC" => Ok(CurrencyPair::LinkUsdc),
            "LINK_USDT" => Ok(CurrencyPair::LinkUsdt),
            "LOOM_BNB" => Ok(CurrencyPair::LoomBnb),
            "LOOM_BTC" => Ok(CurrencyPair::LoomBtc),
            "LOOM_ETH" => Ok(CurrencyPair::LoomEth),
            "LRC_BTC" => Ok(CurrencyPair::LrcBtc),
            "LRC_ETH" => Ok(CurrencyPair::LrcEth),
            "LSK_BNB" => Ok(CurrencyPair::LskBnb),
            "LSK_BTC" => Ok(CurrencyPair::LskBtc),
            "LSK_ETH" => Ok(CurrencyPair::LskEth),
            "LTC_BNB" => Ok(CurrencyPair::LtcBnb),
            "LTC_BTC" => Ok(CurrencyPair::LtcBtc),
            "LTC_BUSD" => Ok(CurrencyPair::LtcBusd),
            "LTC_ETH" => Ok(CurrencyPair::LtcEth),
            "LTC_PAX" => Ok(CurrencyPair::LtcPax),
            "LTC_TUSD" => Ok(CurrencyPair::LtcTusd),
            "LTC_USDC" => Ok(CurrencyPair::LtcUsdc),
            "LTC_USDT" => Ok(CurrencyPair::LtcUsdt),
            "LUN_BTC" => Ok(CurrencyPair::LunBtc),
            "LUN_ETH" => Ok(CurrencyPair::LunEth),
            "MANA_BTC" => Ok(CurrencyPair::ManaBtc),
            "MANA_ETH" => Ok(CurrencyPair::ManaEth),
            "MATIC_BNB" => Ok(CurrencyPair::MaticBnb),
            "MATIC_BTC" => Ok(CurrencyPair::MaticBtc),
            "MATIC_USDT" => Ok(CurrencyPair::MaticUsdt),
            "MCO_BNB" => Ok(CurrencyPair::McoBnb),
            "MCO_BTC" => Ok(CurrencyPair::McoBtc),
            "MCO_ETH" => Ok(CurrencyPair::McoEth),
            "MCO_USDT" => Ok(CurrencyPair::McoUsdt),
            "MDA_BTC" => Ok(CurrencyPair::MdaBtc),
            "MDA_ETH" => Ok(CurrencyPair::MdaEth),
            "MFT_BNB" => Ok(CurrencyPair::MftBnb),
            "MFT_BTC" => Ok(CurrencyPair::MftBtc),
            "MFT_ETH" => Ok(CurrencyPair::MftEth),
            "MFT_USDT" => Ok(CurrencyPair::MftUsdt),
            "MITH_BNB" => Ok(CurrencyPair::MithBnb),
            "MITH_BTC" => Ok(CurrencyPair::MithBtc),
            "MITH_USDT" => Ok(CurrencyPair::MithUsdt),
            "MOD_BTC" => Ok(CurrencyPair::ModBtc),
            "MOD_ETH" => Ok(CurrencyPair::ModEth),
            "MTH_BTC" => Ok(CurrencyPair::MthBtc),
            "MTH_ETH" => Ok(CurrencyPair::MthEth),
            "MTL_BTC" => Ok(CurrencyPair::MtlBtc),
            "MTL_ETH" => Ok(CurrencyPair::MtlEth),
            "MTL_USDT" => Ok(CurrencyPair::MtlUsdt),
            "NANO_BNB" => Ok(CurrencyPair::NanoBnb),
            "NANO_BTC" => Ok(CurrencyPair::NanoBtc),
            "NANO_ETH" => Ok(CurrencyPair::NanoEth),
            "NANO_USDT" => Ok(CurrencyPair::NanoUsdt),
            "NAS_BNB" => Ok(CurrencyPair::NasBnb),
            "NAS_BTC" => Ok(CurrencyPair::NasBtc),
            "NAS_ETH" => Ok(CurrencyPair::NasEth),
            "NAV_BNB" => Ok(CurrencyPair::NavBnb),
            "NAV_BTC" => Ok(CurrencyPair::NavBtc),
            "NAV_ETH" => Ok(CurrencyPair::NavEth),
            "NCASH_BNB" => Ok(CurrencyPair::NcashBnb),
            "NCASH_BTC" => Ok(CurrencyPair::NcashBtc),
            "NCASH_ETH" => Ok(CurrencyPair::NcashEth),
            "NEBL_BNB" => Ok(CurrencyPair::NeblBnb),
            "NEBL_BTC" => Ok(CurrencyPair::NeblBtc),
            "NEBL_ETH" => Ok(CurrencyPair::NeblEth),
            "NEO_BNB" => Ok(CurrencyPair::NeoBnb),
            "NEO_BTC" => Ok(CurrencyPair::NeoBtc),
            "NEO_ETH" => Ok(CurrencyPair::NeoEth),
            "NEO_PAX" => Ok(CurrencyPair::NeoPax),
            "NEO_TUSD" => Ok(CurrencyPair::NeoTusd),
            "NEO_USDC" => Ok(CurrencyPair::NeoUsdc),
            "NEO_USDT" => Ok(CurrencyPair::NeoUsdt),
            "NKN_BNB" => Ok(CurrencyPair::NknBnb),
            "NKN_BTC" => Ok(CurrencyPair::NknBtc),
            "NKN_USDT" => Ok(CurrencyPair::NknUsdt),
            "NPXS_BTC" => Ok(CurrencyPair::NpxsBtc),
            "NPXS_ETH" => Ok(CurrencyPair::NpxsEth),
            "NPXS_USDC" => Ok(CurrencyPair::NpxsUsdc),
            "NPXS_USDT" => Ok(CurrencyPair::NpxsUsdt),
            "NULS_BNB" => Ok(CurrencyPair::NulsBnb),
            "NULS_BTC" => Ok(CurrencyPair::NulsBtc),
            "NULS_ETH" => Ok(CurrencyPair::NulsEth),
            "NULS_USDT" => Ok(CurrencyPair::NulsUsdt),
            "NXS_BNB" => Ok(CurrencyPair::NxsBnb),
            "NXS_BTC" => Ok(CurrencyPair::NxsBtc),
            "NXS_ETH" => Ok(CurrencyPair::NxsEth),
            "OAX_BTC" => Ok(CurrencyPair::OaxBtc),
            "OAX_ETH" => Ok(CurrencyPair::OaxEth),
            "OMG_BNB" => Ok(CurrencyPair::OmgBnb),
            "OMG_BTC" => Ok(CurrencyPair::OmgBtc),
            "OMG_ETH" => Ok(CurrencyPair::OmgEth),
            "OMG_USDT" => Ok(CurrencyPair::OmgUsdt),
            "ONE_BNB" => Ok(CurrencyPair::OneBnb),
            "ONE_BTC" => Ok(CurrencyPair::OneBtc),
            "ONE_PAX" => Ok(CurrencyPair::OnePax),
            "ONE_TUSD" => Ok(CurrencyPair::OneTusd),
            "ONE_USDC" => Ok(CurrencyPair::OneUsdc),
            "ONE_USDT" => Ok(CurrencyPair::OneUsdt),
            "ONG_BNB" => Ok(CurrencyPair::OngBnb),
            "ONG_BTC" => Ok(CurrencyPair::OngBtc),
            "ONG_USDT" => Ok(CurrencyPair::OngUsdt),
            "ONT_BNB" => Ok(CurrencyPair::OntBnb),
            "ONT_BTC" => Ok(CurrencyPair::OntBtc),
            "ONT_ETH" => Ok(CurrencyPair::OntEth),
            "ONT_PAX" => Ok(CurrencyPair::OntPax),
            "ONT_USDC" => Ok(CurrencyPair::OntUsdc),
            "ONT_USDT" => Ok(CurrencyPair::OntUsdt),
            "OST_BNB" => Ok(CurrencyPair::OstBnb),
            "OST_BTC" => Ok(CurrencyPair::OstBtc),
            "OST_ETH" => Ok(CurrencyPair::OstEth),
            "PAX_BNB" => Ok(CurrencyPair::PaxBnb),
            "PAX_BTC" => Ok(CurrencyPair::PaxBtc),
            "PAX_ETH" => Ok(CurrencyPair::PaxEth),
            "PAX_TUSD" => Ok(CurrencyPair::PaxTusd),
            "PAX_USDT" => Ok(CurrencyPair::PaxUsdt),
            "PERL_BNB" => Ok(CurrencyPair::PerlBnb),
            "PERL_BTC" => Ok(CurrencyPair::PerlBtc),
            "PERL_USDC" => Ok(CurrencyPair::PerlUsdc),
            "PERL_USDT" => Ok(CurrencyPair::PerlUsdt),
            "PHB_BNB" => Ok(CurrencyPair::PhbBnb),
            "PHB_BTC" => Ok(CurrencyPair::PhbBtc),
            "PHB_PAX" => Ok(CurrencyPair::PhbPax),
            "PHB_TUSD" => Ok(CurrencyPair::PhbTusd),
            "PHB_USDC" => Ok(CurrencyPair::PhbUsdc),
            "PHX_BNB" => Ok(CurrencyPair::PhxBnb),
            "PHX_BTC" => Ok(CurrencyPair::PhxBtc),
            "PHX_ETH" => Ok(CurrencyPair::PhxEth),
            "PIVX_BNB" => Ok(CurrencyPair::PivxBnb),
            "PIVX_BTC" => Ok(CurrencyPair::PivxBtc),
            "PIVX_ETH" => Ok(CurrencyPair::PivxEth),
            "POA_BNB" => Ok(CurrencyPair::PoaBnb),
            "POA_BTC" => Ok(CurrencyPair::PoaBtc),
            "POA_ETH" => Ok(CurrencyPair::PoaEth),
            "POE_BTC" => Ok(CurrencyPair::PoeBtc),
            "POE_ETH" => Ok(CurrencyPair::PoeEth),
            "POLY_BNB" => Ok(CurrencyPair::PolyBnb),
            "POLY_BTC" => Ok(CurrencyPair::PolyBtc),
            "POWR_BNB" => Ok(CurrencyPair::PowrBnb),
            "POWR_BTC" => Ok(CurrencyPair::PowrBtc),
            "POWR_ETH" => Ok(CurrencyPair::PowrEth),
            "PPT_BTC" => Ok(CurrencyPair::PptBtc),
            "PPT_ETH" => Ok(CurrencyPair::PptEth),
            "QKC_BTC" => Ok(CurrencyPair::QkcBtc),
            "QKC_ETH" => Ok(CurrencyPair::QkcEth),
            "QLC_BNB" => Ok(CurrencyPair::QlcBnb),
            "QLC_BTC" => Ok(CurrencyPair::QlcBtc),
            "QLC_ETH" => Ok(CurrencyPair::QlcEth),
            "QSP_BNB" => Ok(CurrencyPair::QspBnb),
            "QSP_BTC" => Ok(CurrencyPair::QspBtc),
            "QSP_ETH" => Ok(CurrencyPair::QspEth),
            "QTUM_BNB" => Ok(CurrencyPair::QtumBnb),
            "QTUM_BTC" => Ok(CurrencyPair::QtumBtc),
            "QTUM_BUSD" => Ok(CurrencyPair::QtumBusd),
            "QTUM_ETH" => Ok(CurrencyPair::QtumEth),
            "QTUM_USDT" => Ok(CurrencyPair::QtumUsdt),
            "RCN_BNB" => Ok(CurrencyPair::RcnBnb),
            "RCN_BTC" => Ok(CurrencyPair::RcnBtc),
            "RCN_ETH" => Ok(CurrencyPair::RcnEth),
            "RDN_BNB" => Ok(CurrencyPair::RdnBnb),
            "RDN_BTC" => Ok(CurrencyPair::RdnBtc),
            "RDN_ETH" => Ok(CurrencyPair::RdnEth),
            "REN_BNB" => Ok(CurrencyPair::RenBnb),
            "REN_BTC" => Ok(CurrencyPair::RenBtc),
            "REN_USDT" => Ok(CurrencyPair::RenUsdt),
            "REP_BNB" => Ok(CurrencyPair::RepBnb),
            "REP_BTC" => Ok(CurrencyPair::RepBtc),
            "REP_ETH" => Ok(CurrencyPair::RepEth),
            "REQ_BTC" => Ok(CurrencyPair::ReqBtc),
            "REQ_ETH" => Ok(CurrencyPair::ReqEth),
            "RLC_BNB" => Ok(CurrencyPair::RlcBnb),
            "RLC_BTC" => Ok(CurrencyPair::RlcBtc),
            "RLC_ETH" => Ok(CurrencyPair::RlcEth),
            "RLC_USDT" => Ok(CurrencyPair::RlcUsdt),
            "RPX_BNB" => Ok(CurrencyPair::RpxBnb),
            "RPX_BTC" => Ok(CurrencyPair::RpxBtc),
            "RPX_ETH" => Ok(CurrencyPair::RpxEth),
            "RVN_BNB" => Ok(CurrencyPair::RvnBnb),
            "RVN_BTC" => Ok(CurrencyPair::RvnBtc),
            "RVN_USDT" => Ok(CurrencyPair::RvnUsdt),
            "SALT_BTC" => Ok(CurrencyPair::SaltBtc),
            "SALT_ETH" => Ok(CurrencyPair::SaltEth),
            "SC_BNB" => Ok(CurrencyPair::ScBnb),
            "SC_BTC" => Ok(CurrencyPair::ScBtc),
            "SC_ETH" => Ok(CurrencyPair::ScEth),
            "SKY_BNB" => Ok(CurrencyPair::SkyBnb),
            "SKY_BTC" => Ok(CurrencyPair::SkyBtc),
            "SKY_ETH" => Ok(CurrencyPair::SkyEth),
            "SNGLS_BTC" => Ok(CurrencyPair::SnglsBtc),
            "SNGLS_ETH" => Ok(CurrencyPair::SnglsEth),
            "SNM_BTC" => Ok(CurrencyPair::SnmBtc),
            "SNM_ETH" => Ok(CurrencyPair::SnmEth),
            "SNT_BTC" => Ok(CurrencyPair::SntBtc),
            "SNT_ETH" => Ok(CurrencyPair::SntEth),
            "STEEM_BNB" => Ok(CurrencyPair::SteemBnb),
            "STEEM_BTC" => Ok(CurrencyPair::SteemBtc),
            "STEEM_ETH" => Ok(CurrencyPair::SteemEth),
            "STORJ_BTC" => Ok(CurrencyPair::StorjBtc),
            "STORJ_ETH" => Ok(CurrencyPair::StorjEth),
            "STORM_BNB" => Ok(CurrencyPair::StormBnb),
            "STORM_BTC" => Ok(CurrencyPair::StormBtc),
            "STORM_ETH" => Ok(CurrencyPair::StormEth),
            "STORM_USDT" => Ok(CurrencyPair::StormUsdt),
            "STRAT_BTC" => Ok(CurrencyPair::StratBtc),
            "STRAT_ETH" => Ok(CurrencyPair::StratEth),
            "STX_BNB" => Ok(CurrencyPair::StxBnb),
            "STX_BTC" => Ok(CurrencyPair::StxBtc),
            "STX_USDT" => Ok(CurrencyPair::StxUsdt),
            "SUB_BTC" => Ok(CurrencyPair::SubBtc),
            "SUB_ETH" => Ok(CurrencyPair::SubEth),
            "SYS_BNB" => Ok(CurrencyPair::SysBnb),
            "SYS_BTC" => Ok(CurrencyPair::SysBtc),
            "SYS_ETH" => Ok(CurrencyPair::SysEth),
            "TFUEL_BNB" => Ok(CurrencyPair::TfuelBnb),
            "TFUEL_BTC" => Ok(CurrencyPair::TfuelBtc),
            "TFUEL_PAX" => Ok(CurrencyPair::TfuelPax),
            "TFUEL_TUSD" => Ok(CurrencyPair::TfuelTusd),
            "TFUEL_USDC" => Ok(CurrencyPair::TfuelUsdc),
            "TFUEL_USDT" => Ok(CurrencyPair::TfuelUsdt),
            "THETA_BNB" => Ok(CurrencyPair::ThetaBnb),
            "THETA_BTC" => Ok(CurrencyPair::ThetaBtc),
            "THETA_ETH" => Ok(CurrencyPair::ThetaEth),
            "THETA_USDT" => Ok(CurrencyPair::ThetaUsdt),
            "TNB_BTC" => Ok(CurrencyPair::TnbBtc),
            "TNB_ETH" => Ok(CurrencyPair::TnbEth),
            "TNT_BTC" => Ok(CurrencyPair::TntBtc),
            "TNT_ETH" => Ok(CurrencyPair::TntEth),
            "TOMO_BNB" => Ok(CurrencyPair::TomoBnb),
            "TOMO_BTC" => Ok(CurrencyPair::TomoBtc),
            "TOMO_USDC" => Ok(CurrencyPair::TomoUsdc),
            "TOMO_USDT" => Ok(CurrencyPair::TomoUsdt),
            "TRIG_BNB" => Ok(CurrencyPair::TrigBnb),
            "TRIG_BTC" => Ok(CurrencyPair::TrigBtc),
            "TRIG_ETH" => Ok(CurrencyPair::TrigEth),
            "TROY_BNB" => Ok(CurrencyPair::TroyBnb),
            "TROY_BTC" => Ok(CurrencyPair::TroyBtc),
            "TROY_USDT" => Ok(CurrencyPair::TroyUsdt),
            "TRX_BNB" => Ok(CurrencyPair::TrxBnb),
            "TRX_BTC" => Ok(CurrencyPair::TrxBtc),
            "TRX_BUSD" => Ok(CurrencyPair::TrxBusd),
            "TRX_ETH" => Ok(CurrencyPair::TrxEth),
            "TRX_PAX" => Ok(CurrencyPair::TrxPax),
            "TRX_TUSD" => Ok(CurrencyPair::TrxTusd),
            "TRX_USDC" => Ok(CurrencyPair::TrxUsdc),
            "TRX_USDT" => Ok(CurrencyPair::TrxUsdt),
            "TRX_XRP" => Ok(CurrencyPair::TrxXrp),
            "TUSDB_TUSD" => Ok(CurrencyPair::TusdbTusd),
            "TUSD_BNB" => Ok(CurrencyPair::TusdBnb),
            "TUSD_BTC" => Ok(CurrencyPair::TusdBtc),
            "TUSD_ETH" => Ok(CurrencyPair::TusdEth),
            "TUSD_USDT" => Ok(CurrencyPair::TusdUsdt),
            "USDC_BNB" => Ok(CurrencyPair::UsdcBnb),
            "USDC_DASH" => Ok(CurrencyPair::UsdcDash),
            "USDC_GRIN" => Ok(CurrencyPair::UsdcGrin),
            "USDC_PAX" => Ok(CurrencyPair::UsdcPax),
            "USDC_STR" => Ok(CurrencyPair::UsdcStr),
            "USDC_TUSD" => Ok(CurrencyPair::UsdcTusd),
            "USDC_USDT" => Ok(CurrencyPair::UsdcUsdt),
            "USDC_XMR" => Ok(CurrencyPair::UsdcXmr),
            "USDSB_USDS" => Ok(CurrencyPair::UsdsbUsds),
            "USDSB_USDT" => Ok(CurrencyPair::UsdsbUsdt),
            "USDS_PAX" => Ok(CurrencyPair::UsdsPax),
            "USDS_TUSD" => Ok(CurrencyPair::UsdsTusd),
            "USDS_USDC" => Ok(CurrencyPair::UsdsUsdc),
            "USDS_USDT" => Ok(CurrencyPair::UsdsUsdt),
            "USDT_DGB" => Ok(CurrencyPair::UsdtDgb),
            "USDT_GNT" => Ok(CurrencyPair::UsdtGnt),
            "USDT_GRIN" => Ok(CurrencyPair::UsdtGrin),
            "USDT_LSK" => Ok(CurrencyPair::UsdtLsk),
            "USDT_MANA" => Ok(CurrencyPair::UsdtMana),
            "USDT_NXT" => Ok(CurrencyPair::UsdtNxt),
            "USDT_REP" => Ok(CurrencyPair::UsdtRep),
            "USDT_RUB" => Ok(CurrencyPair::UsdtRub),
            "USDT_SC" => Ok(CurrencyPair::UsdtSc),
            "USDT_STR" => Ok(CurrencyPair::UsdtStr),
            "USDT_TRY" => Ok(CurrencyPair::UsdtTry),
            "VEN_BNB" => Ok(CurrencyPair::VenBnb),
            "VEN_BTC" => Ok(CurrencyPair::VenBtc),
            "VEN_ETH" => Ok(CurrencyPair::VenEth),
            "VEN_USDT" => Ok(CurrencyPair::VenUsdt),
            "VET_BNB" => Ok(CurrencyPair::VetBnb),
            "VET_BTC" => Ok(CurrencyPair::VetBtc),
            "VET_BUSD" => Ok(CurrencyPair::VetBusd),
            "VET_ETH" => Ok(CurrencyPair::VetEth),
            "VET_USDT" => Ok(CurrencyPair::VetUsdt),
            "VIA_BNB" => Ok(CurrencyPair::ViaBnb),
            "VIA_BTC" => Ok(CurrencyPair::ViaBtc),
            "VIA_ETH" => Ok(CurrencyPair::ViaEth),
            "VIBE_BTC" => Ok(CurrencyPair::VibeBtc),
            "VIBE_ETH" => Ok(CurrencyPair::VibeEth),
            "VIB_BTC" => Ok(CurrencyPair::VibBtc),
            "VIB_ETH" => Ok(CurrencyPair::VibEth),
            "VITE_BNB" => Ok(CurrencyPair::ViteBnb),
            "VITE_BTC" => Ok(CurrencyPair::ViteBtc),
            "VITE_USDT" => Ok(CurrencyPair::ViteUsdt),
            "WABI_BNB" => Ok(CurrencyPair::WabiBnb),
            "WABI_BTC" => Ok(CurrencyPair::WabiBtc),
            "WABI_ETH" => Ok(CurrencyPair::WabiEth),
            "WAN_BNB" => Ok(CurrencyPair::WanBnb),
            "WAN_BTC" => Ok(CurrencyPair::WanBtc),
            "WAN_ETH" => Ok(CurrencyPair::WanEth),
            "WAN_USDT" => Ok(CurrencyPair::WanUsdt),
            "WAVES_BNB" => Ok(CurrencyPair::WavesBnb),
            "WAVES_BTC" => Ok(CurrencyPair::WavesBtc),
            "WAVES_ETH" => Ok(CurrencyPair::WavesEth),
            "WAVES_PAX" => Ok(CurrencyPair::WavesPax),
            "WAVES_TUSD" => Ok(CurrencyPair::WavesTusd),
            "WAVES_USDC" => Ok(CurrencyPair::WavesUsdc),
            "WAVES_USDT" => Ok(CurrencyPair::WavesUsdt),
            "WINGS_BTC" => Ok(CurrencyPair::WingsBtc),
            "WINGS_ETH" => Ok(CurrencyPair::WingsEth),
            "WIN_BNB" => Ok(CurrencyPair::WinBnb),
            "WIN_BTC" => Ok(CurrencyPair::WinBtc),
            "WIN_TRX" => Ok(CurrencyPair::WinTrx),
            "WIN_USDC" => Ok(CurrencyPair::WinUsdc),
            "WIN_USDT" => Ok(CurrencyPair::WinUsdt),
            "WPR_BTC" => Ok(CurrencyPair::WprBtc),
            "WPR_ETH" => Ok(CurrencyPair::WprEth),
            "WTC_BNB" => Ok(CurrencyPair::WtcBnb),
            "WTC_BTC" => Ok(CurrencyPair::WtcBtc),
            "WTC_ETH" => Ok(CurrencyPair::WtcEth),
            "XEM_BNB" => Ok(CurrencyPair::XemBnb),
            "XEM_BTC" => Ok(CurrencyPair::XemBtc),
            "XEM_ETH" => Ok(CurrencyPair::XemEth),
            "XLM_BNB" => Ok(CurrencyPair::XlmBnb),
            "XLM_BTC" => Ok(CurrencyPair::XlmBtc),
            "XLM_BUSD" => Ok(CurrencyPair::XlmBusd),
            "XLM_ETH" => Ok(CurrencyPair::XlmEth),
            "XLM_PAX" => Ok(CurrencyPair::XlmPax),
            "XLM_TUSD" => Ok(CurrencyPair::XlmTusd),
            "XLM_USDC" => Ok(CurrencyPair::XlmUsdc),
            "XLM_USDT" => Ok(CurrencyPair::XlmUsdt),
            "XMR_BNB" => Ok(CurrencyPair::XmrBnb),
            "XMR_BTC" => Ok(CurrencyPair::XmrBtc),
            "XMR_ETH" => Ok(CurrencyPair::XmrEth),
            "XMR_USDT" => Ok(CurrencyPair::XmrUsdt),
            "XRP_BNB" => Ok(CurrencyPair::XrpBnb),
            "XRP_BTC" => Ok(CurrencyPair::XrpBtc),
            "XRP_BUSD" => Ok(CurrencyPair::XrpBusd),
            "XRP_ETH" => Ok(CurrencyPair::XrpEth),
            "XRP_PAX" => Ok(CurrencyPair::XrpPax),
            "XRP_RUB" => Ok(CurrencyPair::XrpRub),
            "XRP_TRY" => Ok(CurrencyPair::XrpTry),
            "XRP_TUSD" => Ok(CurrencyPair::XrpTusd),
            "XRP_USDC" => Ok(CurrencyPair::XrpUsdc),
            "XRP_USDT" => Ok(CurrencyPair::XrpUsdt),
            "XTZ_BNB" => Ok(CurrencyPair::XtzBnb),
            "XTZ_BTC" => Ok(CurrencyPair::XtzBtc),
            "XTZ_USDT" => Ok(CurrencyPair::XtzUsdt),
            "XVG_BTC" => Ok(CurrencyPair::XvgBtc),
            "XVG_ETH" => Ok(CurrencyPair::XvgEth),
            "XZC_BNB" => Ok(CurrencyPair::XzcBnb),
            "XZC_BTC" => Ok(CurrencyPair::XzcBtc),
            "XZC_ETH" => Ok(CurrencyPair::XzcEth),
            "XZC_XRP" => Ok(CurrencyPair::XzcXrp),
            "YOYO_BNB" => Ok(CurrencyPair::YoyoBnb),
            "YOYO_BTC" => Ok(CurrencyPair::YoyoBtc),
            "YOYO_ETH" => Ok(CurrencyPair::YoyoEth),
            "ZEC_BNB" => Ok(CurrencyPair::ZecBnb),
            "ZEC_BTC" => Ok(CurrencyPair::ZecBtc),
            "ZEC_ETH" => Ok(CurrencyPair::ZecEth),
            "ZEC_PAX" => Ok(CurrencyPair::ZecPax),
            "ZEC_TUSD" => Ok(CurrencyPair::ZecTusd),
            "ZEC_USDC" => Ok(CurrencyPair::ZecUsdc),
            "ZEC_USDT" => Ok(CurrencyPair::ZecUsdt),
            "ZEN_BNB" => Ok(CurrencyPair::ZenBnb),
            "ZEN_BTC" => Ok(CurrencyPair::ZenBtc),
            "ZEN_ETH" => Ok(CurrencyPair::ZenEth),
            "ZIL_BNB" => Ok(CurrencyPair::ZilBnb),
            "ZIL_BTC" => Ok(CurrencyPair::ZilBtc),
            "ZIL_ETH" => Ok(CurrencyPair::ZilEth),
            "ZIL_USDT" => Ok(CurrencyPair::ZilUsdt),
            "ZRX_BNB" => Ok(CurrencyPair::ZrxBnb),
            "ZRX_BTC" => Ok(CurrencyPair::ZrxBtc),
            "ZRX_ETH" => Ok(CurrencyPair::ZrxEth),
            "ZRX_USDT" => Ok(CurrencyPair::ZrxUsdt),
            pair => {
                let index = pair
                    .find('_')
                    .ok_or_else(|| Error::InvalidPair(pair.to_owned()))?;
                if index == pair.len() - 1 {
                    return Err(Error::InvalidPair(pair.to_owned()));
                }
                let quote: Currency = pair[..index].into();
                let base: Currency = pair[index + 1..].into();
                Ok(CurrencyPair::Custom(pair.to_owned(), quote, base))
            }
        }
    }
}

impl Serialize for CurrencyPair {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

struct CurrencyPairVisitor;

impl<'de> Visitor<'de> for CurrencyPairVisitor {
    type Value = CurrencyPair;

    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("currency pair string")
    }

    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        CurrencyPair::from_str(value).map_err(|e| de::Error::custom(e))
    }
}

impl<'de> Deserialize<'de> for CurrencyPair {
    fn deserialize<D>(deserializer: D) -> Result<CurrencyPair, D::Error>
    where
        D: Deserializer<'de>,
    {
        deserializer.deserialize_str(CurrencyPairVisitor)
    }
}

impl ::std::fmt::Display for CurrencyPair {
    fn fmt(&self, f: &mut fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}