@ape.swap/bonds-sdk 1.0.77 → 1.0.78-2.test.10

package/dist/config/constants/products.js

@@ -0,0 +1,58 @@
+var _a, _b;
+// enum to corresponding url
+import { ChainId } from './chains';
+export var LIST_VIEW_PRODUCTS;
+(function (LIST_VIEW_PRODUCTS) {
+    LIST_VIEW_PRODUCTS["BILLS"] = "treasury-bills";
+    LIST_VIEW_PRODUCTS["MAXIMIZERS"] = "maximizers";
+    LIST_VIEW_PRODUCTS["JUNGLE_FARMS"] = "jungle-farms";
+    LIST_VIEW_PRODUCTS["POOLS"] = "pools";
+    LIST_VIEW_PRODUCTS["FARMS"] = "farms";
+    LIST_VIEW_PRODUCTS["EARN"] = "earn";
+})(LIST_VIEW_PRODUCTS || (LIST_VIEW_PRODUCTS = {}));
+export var OTHER_PRODUCTS;
+(function (OTHER_PRODUCTS) {
+    OTHER_PRODUCTS["GNANA"] = "gnana";
+    OTHER_PRODUCTS["MIGRATE"] = "migrate";
+    OTHER_PRODUCTS["ZAP"] = "zap";
+    OTHER_PRODUCTS["IAO"] = "iao";
+    OTHER_PRODUCTS["NFA_COLLECTION"] = "nft";
+    OTHER_PRODUCTS["NFA_AUCTION"] = "auction";
+    OTHER_PRODUCTS["NFA_STAKING"] = "staking";
+    OTHER_PRODUCTS["V3"] = "v3";
+})(OTHER_PRODUCTS || (OTHER_PRODUCTS = {}));
+// Products on different chains and their available chains
+// These products are list view components that have a specific chain redirect component
+export var AVAILABLE_CHAINS_ON_LIST_VIEW_PRODUCTS = (_a = {},
+    _a[LIST_VIEW_PRODUCTS.BILLS] = [
+        ChainId.BSC,
+        ChainId.POLYGON,
+        ChainId.ARBITRUM_ONE,
+        ChainId.INEVM,
+        ChainId.MAINNET,
+        ChainId.LINEA,
+        ChainId.LIGHTLINK,
+    ],
+    _a[LIST_VIEW_PRODUCTS.FARMS] = [ChainId.BSC, ChainId.POLYGON],
+    _a[LIST_VIEW_PRODUCTS.MAXIMIZERS] = [ChainId.BSC],
+    _a[LIST_VIEW_PRODUCTS.JUNGLE_FARMS] = [ChainId.BSC],
+    _a[LIST_VIEW_PRODUCTS.POOLS] = [ChainId.BSC, ChainId.POLYGON, ChainId.MAINNET],
+    _a[LIST_VIEW_PRODUCTS.EARN] = [ChainId.BSC, ChainId.POLYGON, ChainId.MAINNET],
+    _a);
+// Full product names for readability
+export var FULL_PRODUCT_NAMES = (_b = {},
+    _b[LIST_VIEW_PRODUCTS.BILLS] = 'Bonds',
+    _b[LIST_VIEW_PRODUCTS.MAXIMIZERS] = 'Banana Maximizers',
+    _b[LIST_VIEW_PRODUCTS.JUNGLE_FARMS] = 'Jungle Farms',
+    _b[LIST_VIEW_PRODUCTS.POOLS] = 'Pools',
+    _b[LIST_VIEW_PRODUCTS.FARMS] = 'Farms',
+    _b[LIST_VIEW_PRODUCTS.EARN] = 'Earn products',
+    _b[OTHER_PRODUCTS.GNANA] = 'Golden Banana',
+    _b[OTHER_PRODUCTS.MIGRATE] = 'Migrate',
+    _b[OTHER_PRODUCTS.ZAP] = 'Zap',
+    _b[OTHER_PRODUCTS.IAO] = 'Official IAO',
+    _b[OTHER_PRODUCTS.NFA_COLLECTION] = 'Nfa Collection',
+    _b[OTHER_PRODUCTS.NFA_AUCTION] = 'Nfa Auction',
+    _b[OTHER_PRODUCTS.NFA_STAKING] = 'Nfa Staking',
+    _b[OTHER_PRODUCTS.V3] = 'V3 Concentrated Liquidity',
+    _b);

package/dist/config/constants/queryKeys.d.ts

@@ -0,0 +1,24 @@
+export declare const QUERY_KEYS: {
+    INDUSTRY_STATS: string;
+    HISTORICAL_INDUSTRY_STATS: string;
+    LHD_PROFILES: string;
+    LHD_PROFILE: string;
+    LHD_PASSWORD_VERIFIED: string;
+    HOMEPAGE_STATS: string;
+    BOND_PAGE_STATS: string;
+    LIVE_AND_UPCOMING: string;
+    TVL_STATS: string;
+    TOKEN_HISTORIC: string;
+    BONDS_LANDING: string;
+    BOND_POST_REFERENCE: string;
+    BOND_RECOMMENDATIONS: string;
+    TOKEN_PRICES: string;
+    TIERS: string;
+    BOND_STATS: string;
+    USER_STATS: string;
+    HOT_BONDS: string;
+    CHAIN_FILTER_OPTION: string;
+    AB_TEST_VALUE: string;
+    USE_CURRENCY_NEW: string;
+    CURRENCY_BALANCE: string;
+};

package/dist/config/constants/queryKeys.js

@@ -0,0 +1,24 @@
+export var QUERY_KEYS = {
+    INDUSTRY_STATS: 'industryStats',
+    HISTORICAL_INDUSTRY_STATS: 'historicalIndustryStats',
+    LHD_PROFILES: 'lhdProfiles',
+    LHD_PROFILE: 'lhdProfile',
+    LHD_PASSWORD_VERIFIED: 'lhdPasswordVerified',
+    HOMEPAGE_STATS: 'homepageStats',
+    BOND_PAGE_STATS: 'bondPageStats',
+    LIVE_AND_UPCOMING: 'liveAndUpcoming',
+    TVL_STATS: 'tvlStats',
+    TOKEN_HISTORIC: 'tokenHistoric',
+    BONDS_LANDING: 'bondsLanding',
+    BOND_POST_REFERENCE: 'bondPostReference',
+    BOND_RECOMMENDATIONS: 'bondRecommendations',
+    TOKEN_PRICES: 'tokenPrices',
+    TIERS: 'tiers',
+    BOND_STATS: 'bondStats',
+    USER_STATS: 'userStats',
+    HOT_BONDS: 'hotBonds',
+    CHAIN_FILTER_OPTION: 'chainFilterOption',
+    AB_TEST_VALUE: 'ABTestValue',
+    USE_CURRENCY_NEW: 'useCurrencyNew',
+    CURRENCY_BALANCE: 'currencyBalance',
+};

package/dist/config/constants/tokens.d.ts

@@ -0,0 +1,6 @@
+import { NativeCurrency, Token } from '@ape.swap/sdk-core';
+export declare const NATIVE_CHAIN_ID = "NATIVE";
+export declare const WRAPPED_NATIVE_CURRENCY: {
+    [chainId: number]: Token | undefined;
+};
+export declare function nativeOnChain(chainId: number): NativeCurrency | Token;

package/dist/config/constants/tokens.js

@@ -0,0 +1,452 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var _a;
+import { Ether, NativeCurrency, Token, WETH9 } from '@ape.swap/sdk-core';
+import invariant from 'tiny-invariant';
+import { ChainId } from './chains';
+export var NATIVE_CHAIN_ID = 'NATIVE';
+export var WRAPPED_NATIVE_CURRENCY = __assign(__assign({}, WETH9), (_a = {}, _a[ChainId.POLYGON] = new Token(ChainId.POLYGON, '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270', 18, 'WMATIC', 'Wrapped MATIC'), _a[ChainId.BSC] = new Token(ChainId.BSC, '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c', 18, 'WBNB', 'Wrapped BNB'), _a[ChainId.BSC_TESTNET] = new Token(ChainId.BSC_TESTNET, '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c', //this is wrong
+18, 'WBNB', 'Wrapped BNB'), _a[ChainId.TLOS] = new Token(ChainId.TLOS, '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c', 18, 'WTLOS', 'Wrapped TLOS'), _a[ChainId.AVALANCHE] = new Token(ChainId.AVALANCHE, '0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7', 18, 'WAVAX', 'Wrapped AVAX'), _a[ChainId.FANTOM] = new Token(ChainId.FANTOM, '0x21be370d5312f44cb42ce377bc9b8a0cef1a4c83', 18, 'WFTM', 'Wrapped Fantom'), _a[ChainId.POLYGON_ZK] = new Token(ChainId.POLYGON_ZK, '0x4F9A0e7FD2Bf6067db6994CF12E4495Df938E6e9', 18, 'WETH', 'Wrapped ETH'), _a[ChainId.CELO] = new Token(ChainId.CELO, '0x471EcE3750Da237f93B8E339c536989b8978a438', 18, 'CELO', 'CELO'), _a[ChainId.CRONOS] = new Token(ChainId.CRONOS, '0x5C7F8A570d578ED84E63fdFA7b1eE72dEae1AE23', 18, 'WCRO', 'Wrapped CRO'), _a[ChainId.GNOSIS] = new Token(ChainId.GNOSIS, '0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d', 18, 'WXDAI', 'Wrapped xDAI'), _a[ChainId.INJECTED_EVM_TESTNET] = new Token(ChainId.INJECTED_EVM_TESTNET, '0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d', //this is wrong
+18, 'WINJ', 'Wrapped INJ'), _a[ChainId.INEVM] = new Token(ChainId.INEVM, '0x69011706b3f6C6eaeD7D2Bc13801558B4fd94CBF', 18, 'WINJ', 'Wrapped INJ'), _a[ChainId.SEPOLIA] = new Token(ChainId.SEPOLIA, '0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d', //this is wrong
+18, 'WETH', 'Wrapped ETH'), _a[ChainId.LINEA] = new Token(ChainId.LINEA, '0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f', 18, 'WETH', 'Wrapped ETH'), _a[ChainId.LIGHTLINK] = new Token(ChainId.LIGHTLINK, '0x7EbeF2A4b1B09381Ec5B9dF8C5c6f2dBECA59c73', 18, 'WETH', 'Wrapped ETH'), _a[ChainId.IOTA] = new Token(ChainId.IOTA, '0x6e47f8d48a01b44DF3fFF35d258A10A3AEdC114c', 18, 'WIOTA', 'Wrapped IOTA'), _a[ChainId.BASE] = new Token(ChainId.BASE, '0x4200000000000000000000000000000000000006', 18, 'WETH', 'Wrapped ETH'), _a));
+function isMatic(chainId) {
+    return chainId === ChainId.POLYGON;
+}
+function isBNB(chainId) {
+    return chainId === ChainId.BSC;
+}
+function isBNB_Testnet(chainId) {
+    return chainId === ChainId.BSC_TESTNET;
+}
+function isAvax(chainId) {
+    return chainId === ChainId.AVALANCHE;
+}
+function isFantom(chainId) {
+    return chainId === ChainId.FANTOM;
+}
+function isCronos(chainId) {
+    return chainId === ChainId.CRONOS;
+}
+function isGnosis(chainId) {
+    return chainId === ChainId.GNOSIS;
+}
+function isINJ_EVM_TESTNET(chainId) {
+    return chainId === ChainId.INJECTED_EVM_TESTNET;
+}
+function isINEVM(chainId) {
+    return chainId === ChainId.INEVM;
+}
+function isSepolia(chainId) {
+    return chainId === ChainId.SEPOLIA;
+}
+function isLinea(chainId) {
+    return chainId === ChainId.LINEA;
+}
+function isIota(chainId) {
+    return chainId === ChainId.IOTA;
+}
+function isBase(chainId) {
+    return chainId === ChainId.BASE;
+}
+var GnosisNativeCurrency = /** @class */ (function (_super) {
+    __extends(GnosisNativeCurrency, _super);
+    function GnosisNativeCurrency(chainId) {
+        if (!isGnosis(chainId))
+            throw new Error('Not Gnosis');
+        return _super.call(this, chainId, 18, 'xDAI', 'xDai') || this;
+    }
+    GnosisNativeCurrency.prototype.equals = function (other) {
+        return other.isNative && other.chainId === this.chainId;
+    };
+    Object.defineProperty(GnosisNativeCurrency.prototype, "wrapped", {
+        get: function () {
+            if (!isGnosis(this.chainId))
+                throw new Error('Not Gnosis');
+            var wrapped = WRAPPED_NATIVE_CURRENCY[this.chainId];
+            invariant(wrapped instanceof Token);
+            return wrapped;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return GnosisNativeCurrency;
+}(NativeCurrency));
+var CronosNativeCurrency = /** @class */ (function (_super) {
+    __extends(CronosNativeCurrency, _super);
+    function CronosNativeCurrency(chainId) {
+        if (!isCronos(chainId))
+            throw new Error('Not Cronos');
+        return _super.call(this, chainId, 18, 'CRO', 'CRO') || this;
+    }
+    CronosNativeCurrency.prototype.equals = function (other) {
+        return other.isNative && other.chainId === this.chainId;
+    };
+    Object.defineProperty(CronosNativeCurrency.prototype, "wrapped", {
+        get: function () {
+            if (!isCronos(this.chainId))
+                throw new Error('Not Cronos');
+            var wrapped = WRAPPED_NATIVE_CURRENCY[this.chainId];
+            invariant(wrapped instanceof Token);
+            return wrapped;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return CronosNativeCurrency;
+}(NativeCurrency));
+var FantomNativeCurrency = /** @class */ (function (_super) {
+    __extends(FantomNativeCurrency, _super);
+    function FantomNativeCurrency(chainId) {
+        if (!isFantom(chainId))
+            throw new Error('Not Fantom');
+        return _super.call(this, chainId, 18, 'FTM', 'FTM') || this;
+    }
+    FantomNativeCurrency.prototype.equals = function (other) {
+        return other.isNative && other.chainId === this.chainId;
+    };
+    Object.defineProperty(FantomNativeCurrency.prototype, "wrapped", {
+        get: function () {
+            if (!isFantom(this.chainId))
+                throw new Error('Not Fantom');
+            var wrapped = WRAPPED_NATIVE_CURRENCY[this.chainId];
+            invariant(wrapped instanceof Token);
+            return wrapped;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return FantomNativeCurrency;
+}(NativeCurrency));
+var AvaxNativeCurrency = /** @class */ (function (_super) {
+    __extends(AvaxNativeCurrency, _super);
+    function AvaxNativeCurrency(chainId) {
+        if (!isAvax(chainId))
+            throw new Error('Not Avax');
+        return _super.call(this, chainId, 18, 'AVAX', 'Avax') || this;
+    }
+    AvaxNativeCurrency.prototype.equals = function (other) {
+        return other.isNative && other.chainId === this.chainId;
+    };
+    Object.defineProperty(AvaxNativeCurrency.prototype, "wrapped", {
+        get: function () {
+            if (!isAvax(this.chainId))
+                throw new Error('Not Avax');
+            var wrapped = WRAPPED_NATIVE_CURRENCY[this.chainId];
+            invariant(wrapped instanceof Token);
+            return wrapped;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return AvaxNativeCurrency;
+}(NativeCurrency));
+var MaticNativeCurrency = /** @class */ (function (_super) {
+    __extends(MaticNativeCurrency, _super);
+    function MaticNativeCurrency(chainId) {
+        if (!isMatic(chainId))
+            throw new Error('Not matic');
+        return _super.call(this, chainId, 18, 'MATIC', 'MATIC Matic') || this;
+    }
+    MaticNativeCurrency.prototype.equals = function (other) {
+        return other.isNative && other.chainId === this.chainId;
+    };
+    Object.defineProperty(MaticNativeCurrency.prototype, "wrapped", {
+        get: function () {
+            if (!isMatic(this.chainId))
+                throw new Error('Not matic');
+            var wrapped = WRAPPED_NATIVE_CURRENCY[this.chainId];
+            invariant(wrapped instanceof Token);
+            return wrapped;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return MaticNativeCurrency;
+}(NativeCurrency));
+var BNBNativeCurrency = /** @class */ (function (_super) {
+    __extends(BNBNativeCurrency, _super);
+    function BNBNativeCurrency(chainId) {
+        if (!isBNB(chainId))
+            throw new Error('Not bnb');
+        return _super.call(this, chainId, 18, 'BNB', '') || this;
+    }
+    BNBNativeCurrency.prototype.equals = function (other) {
+        return other.isNative && other.chainId === this.chainId;
+    };
+    Object.defineProperty(BNBNativeCurrency.prototype, "wrapped", {
+        get: function () {
+            if (!isBNB(this.chainId))
+                throw new Error('Not bnb');
+            var wrapped = WRAPPED_NATIVE_CURRENCY[this.chainId];
+            invariant(wrapped instanceof Token);
+            return wrapped;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BNBNativeCurrency;
+}(NativeCurrency));
+var tBNBNativeCurrency = /** @class */ (function (_super) {
+    __extends(tBNBNativeCurrency, _super);
+    function tBNBNativeCurrency(chainId) {
+        if (!isBNB_Testnet(chainId))
+            throw new Error('Not bnb testnet');
+        return _super.call(this, chainId, 18, 'tBNB', '') || this;
+    }
+    tBNBNativeCurrency.prototype.equals = function (other) {
+        return other.isNative && other.chainId === this.chainId;
+    };
+    Object.defineProperty(tBNBNativeCurrency.prototype, "wrapped", {
+        get: function () {
+            if (!isBNB_Testnet(this.chainId))
+                throw new Error('Not bnb testnet');
+            var wrapped = WRAPPED_NATIVE_CURRENCY[this.chainId];
+            invariant(wrapped instanceof Token);
+            return wrapped;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return tBNBNativeCurrency;
+}(NativeCurrency));
+var ExtendedEther = /** @class */ (function (_super) {
+    __extends(ExtendedEther, _super);
+    function ExtendedEther() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(ExtendedEther.prototype, "wrapped", {
+        get: function () {
+            var wrapped = WRAPPED_NATIVE_CURRENCY[this.chainId];
+            if (wrapped)
+                return wrapped;
+            throw new Error('Unsupported chain ID');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ExtendedEther.onChain = function (chainId) {
+        var _a;
+        return (_a = this._cachedExtendedEther[chainId]) !== null && _a !== void 0 ? _a : (this._cachedExtendedEther[chainId] = new ExtendedEther(chainId));
+    };
+    ExtendedEther._cachedExtendedEther = {};
+    return ExtendedEther;
+}(Ether));
+var INJ_EVM_TESTNET_NativeCurrency = /** @class */ (function (_super) {
+    __extends(INJ_EVM_TESTNET_NativeCurrency, _super);
+    function INJ_EVM_TESTNET_NativeCurrency(chainId) {
+        if (!isINJ_EVM_TESTNET(chainId))
+            throw new Error('Not INJ test');
+        return _super.call(this, chainId, 18, 'INJ', '') || this;
+    }
+    INJ_EVM_TESTNET_NativeCurrency.prototype.equals = function (other) {
+        return other.isNative && other.chainId === this.chainId;
+    };
+    Object.defineProperty(INJ_EVM_TESTNET_NativeCurrency.prototype, "wrapped", {
+        get: function () {
+            if (!isINJ_EVM_TESTNET(this.chainId))
+                throw new Error('Not INJ test');
+            var wrapped = WRAPPED_NATIVE_CURRENCY[this.chainId];
+            invariant(wrapped instanceof Token);
+            return wrapped;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return INJ_EVM_TESTNET_NativeCurrency;
+}(NativeCurrency));
+var INEVM_NativeCurrency = /** @class */ (function (_super) {
+    __extends(INEVM_NativeCurrency, _super);
+    function INEVM_NativeCurrency(chainId) {
+        if (!isINEVM(chainId))
+            throw new Error('Not INEVM');
+        return _super.call(this, chainId, 18, 'INJ', '') || this;
+    }
+    INEVM_NativeCurrency.prototype.equals = function (other) {
+        return other.isNative && other.chainId === this.chainId;
+    };
+    Object.defineProperty(INEVM_NativeCurrency.prototype, "wrapped", {
+        get: function () {
+            if (!isINEVM(this.chainId))
+                throw new Error('Not INEVM');
+            var wrapped = WRAPPED_NATIVE_CURRENCY[this.chainId];
+            invariant(wrapped instanceof Token);
+            return wrapped;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return INEVM_NativeCurrency;
+}(NativeCurrency));
+var Sepolia_NativeCurrency = /** @class */ (function (_super) {
+    __extends(Sepolia_NativeCurrency, _super);
+    function Sepolia_NativeCurrency(chainId) {
+        if (!isSepolia(chainId))
+            throw new Error('Not Sepolia');
+        return _super.call(this, chainId, 18, 'ETH', '') || this;
+    }
+    Sepolia_NativeCurrency.prototype.equals = function (other) {
+        return other.isNative && other.chainId === this.chainId;
+    };
+    Object.defineProperty(Sepolia_NativeCurrency.prototype, "wrapped", {
+        get: function () {
+            if (!isSepolia(this.chainId))
+                throw new Error('Not Sepolia');
+            var wrapped = WRAPPED_NATIVE_CURRENCY[this.chainId];
+            invariant(wrapped instanceof Token);
+            return wrapped;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Sepolia_NativeCurrency;
+}(NativeCurrency));
+var LineaNativeCurrency = /** @class */ (function (_super) {
+    __extends(LineaNativeCurrency, _super);
+    function LineaNativeCurrency(chainId) {
+        if (!isLinea(chainId))
+            throw new Error('Not linea');
+        return _super.call(this, chainId, 18, 'ETH', '') || this;
+    }
+    LineaNativeCurrency.prototype.equals = function (other) {
+        return other.isNative && other.chainId === this.chainId;
+    };
+    Object.defineProperty(LineaNativeCurrency.prototype, "wrapped", {
+        get: function () {
+            if (!isLinea(this.chainId))
+                throw new Error('Not linea');
+            var wrapped = WRAPPED_NATIVE_CURRENCY[this.chainId];
+            invariant(wrapped instanceof Token);
+            return wrapped;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return LineaNativeCurrency;
+}(NativeCurrency));
+var IotaNativeCurrency = /** @class */ (function (_super) {
+    __extends(IotaNativeCurrency, _super);
+    function IotaNativeCurrency(chainId) {
+        if (!isIota(chainId))
+            throw new Error('Not iota');
+        return _super.call(this, chainId, 18, 'IOTA', '') || this;
+    }
+    IotaNativeCurrency.prototype.equals = function (other) {
+        return other.isNative && other.chainId === this.chainId;
+    };
+    Object.defineProperty(IotaNativeCurrency.prototype, "wrapped", {
+        get: function () {
+            if (!isIota(this.chainId))
+                throw new Error('Not iota');
+            var wrapped = WRAPPED_NATIVE_CURRENCY[this.chainId];
+            invariant(wrapped instanceof Token);
+            return wrapped;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return IotaNativeCurrency;
+}(NativeCurrency));
+var BaseNativeCurrency = /** @class */ (function (_super) {
+    __extends(BaseNativeCurrency, _super);
+    function BaseNativeCurrency(chainId) {
+        if (!isBase(chainId))
+            throw new Error('Not Base');
+        return _super.call(this, chainId, 18, 'ETH', '') || this;
+    }
+    BaseNativeCurrency.prototype.equals = function (other) {
+        return other.isNative && other.chainId === this.chainId;
+    };
+    Object.defineProperty(BaseNativeCurrency.prototype, "wrapped", {
+        get: function () {
+            if (!isBase(this.chainId))
+                throw new Error('Not Base');
+            var wrapped = WRAPPED_NATIVE_CURRENCY[this.chainId];
+            invariant(wrapped instanceof Token);
+            return wrapped;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BaseNativeCurrency;
+}(NativeCurrency));
+var cachedNativeCurrency = {};
+export function nativeOnChain(chainId) {
+    if (cachedNativeCurrency[chainId])
+        return cachedNativeCurrency[chainId];
+    var nativeCurrency;
+    //TODO: find a more elegant solution
+    var selectedChain;
+    if (typeof chainId === 'string') {
+        selectedChain = parseInt(chainId);
+    }
+    else {
+        selectedChain = chainId;
+    }
+    if (isMatic(selectedChain)) {
+        nativeCurrency = new MaticNativeCurrency(selectedChain);
+    }
+    else if (isBNB(selectedChain)) {
+        nativeCurrency = new BNBNativeCurrency(selectedChain);
+    }
+    else if (isBNB_Testnet(selectedChain)) {
+        nativeCurrency = new tBNBNativeCurrency(selectedChain);
+    }
+    else if (isAvax(selectedChain)) {
+        nativeCurrency = new AvaxNativeCurrency(selectedChain);
+    }
+    else if (isFantom(selectedChain)) {
+        nativeCurrency = new FantomNativeCurrency(selectedChain);
+    }
+    else if (isCronos(selectedChain)) {
+        nativeCurrency = new CronosNativeCurrency(selectedChain);
+    }
+    else if (isGnosis(selectedChain)) {
+        nativeCurrency = new GnosisNativeCurrency(selectedChain);
+    }
+    else if (isINJ_EVM_TESTNET(selectedChain)) {
+        nativeCurrency = new INJ_EVM_TESTNET_NativeCurrency(selectedChain);
+    }
+    else if (isINEVM(selectedChain)) {
+        nativeCurrency = new INEVM_NativeCurrency(selectedChain);
+    }
+    else if (isSepolia(selectedChain)) {
+        nativeCurrency = new Sepolia_NativeCurrency(selectedChain);
+    }
+    else if (isLinea(selectedChain)) {
+        nativeCurrency = new LineaNativeCurrency(selectedChain);
+    }
+    else if (isIota(selectedChain)) {
+        nativeCurrency = new IotaNativeCurrency(selectedChain);
+    }
+    else if (isBase(selectedChain)) {
+        nativeCurrency = new BaseNativeCurrency(selectedChain);
+    }
+    else {
+        nativeCurrency = ExtendedEther.onChain(selectedChain);
+    }
+    return (cachedNativeCurrency[selectedChain] = nativeCurrency);
+}

package/dist/config/constants/tutorials.d.ts

@@ -0,0 +1,7 @@
+import { SupportedChainId } from '@ape.swap/sdk-core';
+export declare const getMetamaskLinks: (chainId: SupportedChainId) => "https://docs.bnbchain.org/docs/wallet/metamask/" | "https://wiki.polygon.technology/docs/tools/wallets/metamask/config-polygon-on-metamask/" | "https://metamask.io/faqs/" | "https://decentralizedcreator.com/add-telos-evm-network-to-metamask/" | "https://academy.binance.com/en/articles/how-to-add-arbitrum-to-metamask";
+export declare const ROUTE_NAMES: Record<string, string>;
+export declare const FARMS: Record<string, string>;
+export declare const apebond = "https://docs.ape.bond/apebond/";
+export declare const APEBOND_DOC_LINKS: Record<string, string>;
+export declare const HELP_LINK: string;

package/dist/config/constants/tutorials.js

@@ -0,0 +1,80 @@
+import { SupportedChainId } from '@ape.swap/sdk-core';
+export var getMetamaskLinks = function (chainId) {
+    switch (chainId) {
+        case SupportedChainId.BSC:
+            return 'https://docs.bnbchain.org/docs/wallet/metamask/';
+        case SupportedChainId.POLYGON:
+            return 'https://wiki.polygon.technology/docs/tools/wallets/metamask/config-polygon-on-metamask/';
+        case SupportedChainId.MAINNET:
+            return 'https://metamask.io/faqs/';
+        case SupportedChainId.TLOS:
+            return 'https://decentralizedcreator.com/add-telos-evm-network-to-metamask/';
+        case SupportedChainId.ARBITRUM_ONE:
+            return 'https://academy.binance.com/en/articles/how-to-add-arbitrum-to-metamask';
+        default:
+            return 'https://docs.bnbchain.org/docs/wallet/metamask/';
+    }
+};
+export var ROUTE_NAMES = {
+    '/': 'HOME',
+    '/jungle-farms': 'JUNGLE_FARMS',
+    '/farms': 'FARMS',
+    '/swap': 'SWAP',
+    '/pools': 'POOLS',
+    '/maximizers': 'MAXIMIZERS_VAULTS',
+    '/add': 'ADD_LIQUIDITY',
+    //'/v3-add-liquidity': 'ADD_LIQUIDITY',
+    '/add-liquidity': 'ADD_LIQUIDITY_V2',
+    '/liquidity': 'ADD_LIQUIDITY_V2',
+    '/zap': 'ADD_LIQUIDITY_V2',
+    '/migrate': 'ADD_LIQUIDITY_V2',
+    '/find': 'ADD_LIQUIDITY_V2',
+    '/remove': 'ADD_LIQUIDITY_V2',
+    '/limit-orders': 'ORDERS',
+    '/iao': 'IAO',
+    '/gnana': 'GNANA',
+    '/bonds': 'TREASURY_BILL',
+    '/nft': 'NFT',
+    '/auction': 'AUCTION',
+    '/staking': 'STAKING',
+    '/apestats': 'APESTATS',
+    '/protocol-dashboard': 'PROTOCOL_DASHBOARD',
+    '/the-migration': 'THE_MIGRATION',
+    '/liquidity-health': 'LIQUIDITY_HEALTH',
+    '/migration': 'MIGRATION',
+    '/earn': 'EARN',
+    '/launchpad': 'LAUNCHPAD',
+};
+export var FARMS = {
+    BNB: 'bnb-chain-farms',
+    Polygon: 'polygon-farms',
+    Ethereum: '',
+    Telos: 'telos-farms',
+};
+export var apebond = 'https://docs.ape.bond/apebond/';
+export var APEBOND_DOC_LINKS = {
+    HOME: "welcome/master",
+    JUNGLE_FARMS: 'products-and-features/stake/farms',
+    FARMS: "products-and-features/stake/farms",
+    SWAP: 'products-and-features/swap',
+    POOLS: 'products-and-features/stake/pools',
+    MAXIMIZERS_VAULTS: 'products-and-features/stake/vaults',
+    ADD_LIQUIDITY: 'products-and-features/exchange/liquidity/how-to-add-liquidity-v3',
+    ADD_LIQUIDITY_V2: 'products-and-features/exchange/liquidity/how-to-add-liquidity-v2',
+    LIQUIDITY: 'products-and-features/exchange/liquidity/how-to-add-liquidity-v3',
+    ORDERS: 'products-and-features/exchange/limit-orders',
+    IAO: 'products-and-features/raise/initial-ape-offerings-iaos',
+    GNANA: 'welcome/apeswap-tokens/gnana',
+    TREASURY_BILL: 'products-and-features/bonds',
+    NFT: 'products-and-features/collect/non-fungible-apes-nfas',
+    AUCTION: 'products-and-features/collect/non-fungible-apes-nfas/nfa-auction-house',
+    STAKING: 'products-and-features/stake',
+    APESTATS: 'products-and-features/apestats',
+    PROTOCOL_DASHBOARD: 'products-and-features/protocol-dashboard',
+    THE_MIGRATION: 'products-and-features/stake/hard-cap-migration-masterapev2',
+    LIQUIDITY_HEALTH: 'products-and-features/liquidity-health',
+    MIGRATION: 'products-and-features/abond-migration',
+    EARN: 'products-and-features/stake',
+    LAUNCHPAD: 'products-and-features/launchpad',
+};
+export var HELP_LINK = 'https://discord.com/channels/821817977917538375/1110438345701593088';

package/dist/config/localization/languages.d.ts

@@ -0,0 +1,11 @@
+import { Language } from '../../contexts/Localization/types';
+export declare const EN: Language;
+export declare const ESES: Language;
+export declare const JA: Language;
+export declare const PTBR: Language;
+export declare const RU: Language;
+export declare const TR: Language;
+export declare const ZHCN: Language;
+export declare const ZHTW: Language;
+export declare const languages: Record<string, Language>;
+export declare const languageList: Language[];