@curvefi/api 2.31.0 → 2.31.1

package/lib/pools/poolConstructor.js

@@ -1,235 +1,211 @@
-"use strict";
-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 __());
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPool = void 0;
-var curve_1 = require("../curve");
-var PoolTemplate_1 = require("./PoolTemplate");
-var poolBalancesMixin_1 = require("./mixins/poolBalancesMixin");
-var depositBalancedAmountsMixins_1 = require("./mixins/depositBalancedAmountsMixins");
-var depositMixins_1 = require("./mixins/depositMixins");
-var depositWrappedMixins_1 = require("./mixins/depositWrappedMixins");
-var withdrawExpectedMixins_1 = require("./mixins/withdrawExpectedMixins");
-var withdrawMixins_1 = require("./mixins/withdrawMixins");
-var withdrawWrappedMixins_1 = require("./mixins/withdrawWrappedMixins");
-var withdrawImbalanceMixins_1 = require("./mixins/withdrawImbalanceMixins");
-var withdrawImbalanceWrappedMixins_1 = require("./mixins/withdrawImbalanceWrappedMixins");
-var withdrawOneCoinExpectedMixins_1 = require("./mixins/withdrawOneCoinExpectedMixins");
-var withdrawOneCoinMixins_1 = require("./mixins/withdrawOneCoinMixins");
-var withdrawOneCoinWrappedExpectedMixins_1 = require("./mixins/withdrawOneCoinWrappedExpectedMixins");
-var withdrawOneCoinWrappedMixins_1 = require("./mixins/withdrawOneCoinWrappedMixins");
-var swapMixins_1 = require("./mixins/swapMixins");
-var swapWrappedMixins_1 = require("./mixins/swapWrappedMixins");
-var getPool = function (poolId) {
-    var poolDummy = new PoolTemplate_1.PoolTemplate(poolId);
-    var Pool = /** @class */ (function (_super) {
-        __extends(Pool, _super);
-        function Pool() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        return Pool;
-    }(PoolTemplate_1.PoolTemplate));
+import { curve } from "../curve.js";
+import { PoolTemplate } from "./PoolTemplate.js";
+import { poolBalancesMetaMixin, poolBalancesLendingMixin } from "./mixins/poolBalancesMixin.js";
+import { depositBalancedAmountsMixin, depositBalancedAmountsCryptoMixin, depositWrappedBalancedAmountsMixin, depositWrappedBalancedAmountsCryptoMixin } from "./mixins/depositBalancedAmountsMixins.js";
+import { depositMetaFactoryMixin, depositCryptoMetaFactoryMixin, depositZapMixin, depositLendingOrCryptoMixin, depositPlainMixin } from "./mixins/depositMixins.js";
+import { depositWrapped2argsMixin, depositWrapped3argsMixin } from "./mixins/depositWrappedMixins.js";
+import { withdrawExpectedMixin, withdrawExpectedLendingOrCryptoMixin, withdrawExpectedMetaMixin, withdrawWrappedExpectedMixin } from "./mixins/withdrawExpectedMixins.js";
+import { withdrawMetaFactoryMixin, withdrawCryptoMetaFactoryMixin, withdrawZapMixin, withdrawLendingOrCryptoMixin, withdrawPlainMixin } from "./mixins/withdrawMixins.js";
+import { withdrawWrapped2argsMixin, withdrawWrapped3argsMixin } from "./mixins/withdrawWrappedMixins.js";
+import { withdrawImbalanceMetaFactoryMixin, withdrawImbalanceZapMixin, withdrawImbalanceLendingMixin, withdrawImbalancePlainMixin } from "./mixins/withdrawImbalanceMixins.js";
+import { withdrawImbalanceWrapped2argsMixin, withdrawImbalanceWrapped3argsMixin } from "./mixins/withdrawImbalanceWrappedMixins.js";
+import { withdrawOneCoinExpectedMetaFactoryMixin, withdrawOneCoinExpectedZapMixin, withdrawOneCoinExpected3argsMixin, withdrawOneCoinExpected2argsMixin } from "./mixins/withdrawOneCoinExpectedMixins.js";
+import { withdrawOneCoinMetaFactoryMixin, withdrawOneCoinCryptoMetaFactoryMixin, withdrawOneCoinZapMixin, withdrawOneCoinLendingOrCryptoMixin, withdrawOneCoinPlainMixin } from "./mixins/withdrawOneCoinMixins.js";
+import { withdrawOneCoinWrappedExpected2argsMixin, withdrawOneCoinWrappedExpected3argsMixin } from "./mixins/withdrawOneCoinWrappedExpectedMixins.js";
+import { withdrawOneCoinWrappedLendingOrCryptoMixin, withdrawOneCoinWrappedMixin } from "./mixins/withdrawOneCoinWrappedMixins.js";
+import { swapTricrypto2Mixin, swapMetaFactoryMixin, swapCryptoMetaFactoryMixin, swapMixin } from "./mixins/swapMixins.js";
+import { swapWrappedExpectedAndApproveMixin, swapWrappedTricrypto2Mixin, swapWrappedMixin } from "./mixins/swapWrappedMixins.js";
+export const getPool = (poolId) => {
+    const poolDummy = new PoolTemplate(poolId);
+    class Pool extends PoolTemplate {
+    }
     // statsBalances
     if (poolDummy.isMeta) {
-        Object.assign(Pool.prototype, poolBalancesMixin_1.poolBalancesMetaMixin);
+        Object.assign(Pool.prototype, poolBalancesMetaMixin);
     }
-    else if (poolDummy.useLending.reduce(function (x, y) { return x || y; })) {
-        Object.assign(Pool.prototype, poolBalancesMixin_1.poolBalancesLendingMixin);
+    else if (poolDummy.useLending.reduce((x, y) => x || y)) {
+        Object.assign(Pool.prototype, poolBalancesLendingMixin);
     }
     // depositBalancedAmounts
     if (poolDummy.isCrypto) {
-        Object.assign(Pool.prototype, depositBalancedAmountsMixins_1.depositBalancedAmountsCryptoMixin);
+        Object.assign(Pool.prototype, depositBalancedAmountsCryptoMixin);
     }
     else {
-        Object.assign(Pool.prototype, depositBalancedAmountsMixins_1.depositBalancedAmountsMixin);
+        Object.assign(Pool.prototype, depositBalancedAmountsMixin);
     }
     // depositWrappedBalancedAmounts
     if (!poolDummy.isPlain && !poolDummy.isFake) {
         if (poolDummy.isCrypto) {
-            Object.assign(Pool.prototype, depositBalancedAmountsMixins_1.depositWrappedBalancedAmountsCryptoMixin);
+            Object.assign(Pool.prototype, depositWrappedBalancedAmountsCryptoMixin);
         }
         else {
-            Object.assign(Pool.prototype, depositBalancedAmountsMixins_1.depositWrappedBalancedAmountsMixin);
+            Object.assign(Pool.prototype, depositWrappedBalancedAmountsMixin);
         }
     }
     // deposit and depositEstimateGas
     if (poolDummy.isMetaFactory) {
         if (poolDummy.isCrypto) {
-            Object.assign(Pool.prototype, depositMixins_1.depositCryptoMetaFactoryMixin);
+            Object.assign(Pool.prototype, depositCryptoMetaFactoryMixin);
         }
         else {
-            Object.assign(Pool.prototype, depositMixins_1.depositMetaFactoryMixin);
+            Object.assign(Pool.prototype, depositMetaFactoryMixin);
         }
     }
     else if (poolDummy.zap && poolId !== 'susd') {
-        Object.assign(Pool.prototype, depositMixins_1.depositZapMixin);
+        Object.assign(Pool.prototype, depositZapMixin);
     }
     else if (poolDummy.isLending || (poolDummy.isCrypto && !poolDummy.isPlain)) {
-        Object.assign(Pool.prototype, depositMixins_1.depositLendingOrCryptoMixin);
+        Object.assign(Pool.prototype, depositLendingOrCryptoMixin);
     }
     else {
-        Object.assign(Pool.prototype, depositMixins_1.depositPlainMixin);
+        Object.assign(Pool.prototype, depositPlainMixin);
     }
     // depositWrapped and depositWrappedEstimateGas
     if (!poolDummy.isPlain && !poolDummy.isFake) {
         if (((poolDummy.isLending || poolDummy.isCrypto) && !poolDummy.zap) || (poolDummy.isCrypto && poolDummy.isMetaFactory)) {
-            Object.assign(Pool.prototype, depositWrappedMixins_1.depositWrapped3argsMixin);
+            Object.assign(Pool.prototype, depositWrapped3argsMixin);
         }
         else {
-            Object.assign(Pool.prototype, depositWrappedMixins_1.depositWrapped2argsMixin);
+            Object.assign(Pool.prototype, depositWrapped2argsMixin);
         }
     }
     // withdrawExpected
     if (poolDummy.isMeta) {
-        Object.assign(Pool.prototype, withdrawExpectedMixins_1.withdrawExpectedMetaMixin);
+        Object.assign(Pool.prototype, withdrawExpectedMetaMixin);
     }
     else if (poolDummy.isLending || (poolDummy.isCrypto && !poolDummy.isPlain)) {
-        Object.assign(Pool.prototype, withdrawExpectedMixins_1.withdrawExpectedLendingOrCryptoMixin);
+        Object.assign(Pool.prototype, withdrawExpectedLendingOrCryptoMixin);
     }
     else {
-        Object.assign(Pool.prototype, withdrawExpectedMixins_1.withdrawExpectedMixin);
+        Object.assign(Pool.prototype, withdrawExpectedMixin);
     }
     // withdraw and withdrawEstimateGas
     if (poolDummy.isMetaFactory) {
         if (poolDummy.isCrypto) {
-            Object.assign(Pool.prototype, withdrawMixins_1.withdrawCryptoMetaFactoryMixin);
+            Object.assign(Pool.prototype, withdrawCryptoMetaFactoryMixin);
         }
         else {
-            Object.assign(Pool.prototype, withdrawMixins_1.withdrawMetaFactoryMixin);
+            Object.assign(Pool.prototype, withdrawMetaFactoryMixin);
         }
     }
     else if (poolDummy.zap && poolId !== 'susd') {
-        Object.assign(Pool.prototype, withdrawMixins_1.withdrawZapMixin);
+        Object.assign(Pool.prototype, withdrawZapMixin);
     }
     else if (poolDummy.isLending || (poolDummy.isCrypto && !poolDummy.isPlain)) {
-        Object.assign(Pool.prototype, withdrawMixins_1.withdrawLendingOrCryptoMixin);
+        Object.assign(Pool.prototype, withdrawLendingOrCryptoMixin);
     }
     else {
-        Object.assign(Pool.prototype, withdrawMixins_1.withdrawPlainMixin);
+        Object.assign(Pool.prototype, withdrawPlainMixin);
     }
     // withdrawWrapped and withdrawWrappedEstimateGas
     if (!poolDummy.isPlain && !poolDummy.isFake) {
         if (((poolDummy.isLending || poolDummy.isCrypto) && !poolDummy.zap) || (poolDummy.isCrypto && poolDummy.isMetaFactory)) {
-            Object.assign(Pool.prototype, withdrawWrappedMixins_1.withdrawWrapped3argsMixin);
-            Object.assign(Pool.prototype, withdrawExpectedMixins_1.withdrawWrappedExpectedMixin);
+            Object.assign(Pool.prototype, withdrawWrapped3argsMixin);
+            Object.assign(Pool.prototype, withdrawWrappedExpectedMixin);
         }
         else {
-            Object.assign(Pool.prototype, withdrawWrappedMixins_1.withdrawWrapped2argsMixin);
-            Object.assign(Pool.prototype, withdrawExpectedMixins_1.withdrawWrappedExpectedMixin);
+            Object.assign(Pool.prototype, withdrawWrapped2argsMixin);
+            Object.assign(Pool.prototype, withdrawWrappedExpectedMixin);
         }
     }
     // withdrawImbalance and withdrawImbalanceEstimateGas
     if (!poolDummy.isCrypto) {
         if (poolDummy.isMetaFactory) {
-            Object.assign(Pool.prototype, withdrawImbalanceMixins_1.withdrawImbalanceMetaFactoryMixin);
+            Object.assign(Pool.prototype, withdrawImbalanceMetaFactoryMixin);
         }
         else if (poolDummy.zap && poolId !== 'susd') {
-            Object.assign(Pool.prototype, withdrawImbalanceMixins_1.withdrawImbalanceZapMixin);
+            Object.assign(Pool.prototype, withdrawImbalanceZapMixin);
         }
         else if (poolDummy.isLending) {
-            Object.assign(Pool.prototype, withdrawImbalanceMixins_1.withdrawImbalanceLendingMixin);
+            Object.assign(Pool.prototype, withdrawImbalanceLendingMixin);
         }
         else {
-            Object.assign(Pool.prototype, withdrawImbalanceMixins_1.withdrawImbalancePlainMixin);
+            Object.assign(Pool.prototype, withdrawImbalancePlainMixin);
         }
     }
     // withdrawImbalanceWrapped and withdrawImbalanceWrappedEstimateGas
     if (!poolDummy.isCrypto) {
         if (poolDummy.isLending && !poolDummy.zap) {
-            Object.assign(Pool.prototype, withdrawImbalanceWrappedMixins_1.withdrawImbalanceWrapped3argsMixin);
+            Object.assign(Pool.prototype, withdrawImbalanceWrapped3argsMixin);
         }
         else if (!poolDummy.isPlain && !poolDummy.isFake) {
-            Object.assign(Pool.prototype, withdrawImbalanceWrappedMixins_1.withdrawImbalanceWrapped2argsMixin);
+            Object.assign(Pool.prototype, withdrawImbalanceWrapped2argsMixin);
         }
     }
     // withdrawOneCoinExpected
     if (poolDummy.isMetaFactory) {
-        Object.assign(Pool.prototype, withdrawOneCoinExpectedMixins_1.withdrawOneCoinExpectedMetaFactoryMixin);
+        Object.assign(Pool.prototype, withdrawOneCoinExpectedMetaFactoryMixin);
     }
     else if ((!poolDummy.isCrypto && poolDummy.zap) || poolDummy.isMeta) { // including susd
-        Object.assign(Pool.prototype, withdrawOneCoinExpectedMixins_1.withdrawOneCoinExpectedZapMixin);
+        Object.assign(Pool.prototype, withdrawOneCoinExpectedZapMixin);
     }
     else if (poolId === 'ib') {
-        Object.assign(Pool.prototype, withdrawOneCoinExpectedMixins_1.withdrawOneCoinExpected3argsMixin);
+        Object.assign(Pool.prototype, withdrawOneCoinExpected3argsMixin);
     }
     else {
-        Object.assign(Pool.prototype, withdrawOneCoinExpectedMixins_1.withdrawOneCoinExpected2argsMixin);
+        Object.assign(Pool.prototype, withdrawOneCoinExpected2argsMixin);
     }
     // withdrawOneCoin and withdrawOneCoinEstimateGas
     if (poolDummy.isMetaFactory) {
         if (poolDummy.isCrypto) {
-            Object.assign(Pool.prototype, withdrawOneCoinMixins_1.withdrawOneCoinCryptoMetaFactoryMixin);
+            Object.assign(Pool.prototype, withdrawOneCoinCryptoMetaFactoryMixin);
         }
         else {
-            Object.assign(Pool.prototype, withdrawOneCoinMixins_1.withdrawOneCoinMetaFactoryMixin);
+            Object.assign(Pool.prototype, withdrawOneCoinMetaFactoryMixin);
         }
     }
     else if (poolDummy.zap) { // including susd
-        Object.assign(Pool.prototype, withdrawOneCoinMixins_1.withdrawOneCoinZapMixin);
+        Object.assign(Pool.prototype, withdrawOneCoinZapMixin);
     }
     else if (poolDummy.isLending || (poolDummy.isCrypto && !poolDummy.isPlain)) {
-        Object.assign(Pool.prototype, withdrawOneCoinMixins_1.withdrawOneCoinLendingOrCryptoMixin);
+        Object.assign(Pool.prototype, withdrawOneCoinLendingOrCryptoMixin);
     }
     else {
-        Object.assign(Pool.prototype, withdrawOneCoinMixins_1.withdrawOneCoinPlainMixin);
+        Object.assign(Pool.prototype, withdrawOneCoinPlainMixin);
     }
     // withdrawOneCoinWrappedExpected
     if (!poolDummy.isPlain && !poolDummy.isFake && !(poolDummy.isLending && poolDummy.zap)) {
         if (poolId === "ib") {
-            Object.assign(Pool.prototype, withdrawOneCoinWrappedExpectedMixins_1.withdrawOneCoinWrappedExpected3argsMixin);
+            Object.assign(Pool.prototype, withdrawOneCoinWrappedExpected3argsMixin);
         }
         else {
-            Object.assign(Pool.prototype, withdrawOneCoinWrappedExpectedMixins_1.withdrawOneCoinWrappedExpected2argsMixin);
+            Object.assign(Pool.prototype, withdrawOneCoinWrappedExpected2argsMixin);
         }
     }
     // withdrawOneCoinWrapped and withdrawOneCoinWrappedEstimateGas
     if (!poolDummy.isPlain && !poolDummy.isFake && !(poolDummy.isLending && poolDummy.zap)) {
         if (((poolDummy.isLending || poolDummy.isCrypto) && !poolDummy.zap) || (poolDummy.isCrypto && poolDummy.isMetaFactory)) {
-            Object.assign(Pool.prototype, withdrawOneCoinWrappedMixins_1.withdrawOneCoinWrappedLendingOrCryptoMixin);
+            Object.assign(Pool.prototype, withdrawOneCoinWrappedLendingOrCryptoMixin);
         }
         else {
-            Object.assign(Pool.prototype, withdrawOneCoinWrappedMixins_1.withdrawOneCoinWrappedMixin);
+            Object.assign(Pool.prototype, withdrawOneCoinWrappedMixin);
         }
     }
     // swap and swapEstimateGas
-    if ('exchange(uint256,uint256,uint256,uint256,bool)' in curve_1.curve.contracts[poolDummy.address].contract &&
-        !(curve_1.curve.chainId === 100 && poolDummy.id === "tricrypto")) { // tricrypto2 (eth), tricrypto (arbitrum), avaxcrypto (avalanche); 100 is xDAI
-        Object.assign(Pool.prototype, swapMixins_1.swapTricrypto2Mixin);
+    if ('exchange(uint256,uint256,uint256,uint256,bool)' in curve.contracts[poolDummy.address].contract &&
+        !(curve.chainId === 100 && poolDummy.id === "tricrypto")) { // tricrypto2 (eth), tricrypto (arbitrum), avaxcrypto (avalanche); 100 is xDAI
+        Object.assign(Pool.prototype, swapTricrypto2Mixin);
     }
-    else if (poolDummy.isMetaFactory && ((0, exports.getPool)(poolDummy.basePool).isLending || (0, exports.getPool)(poolDummy.basePool).isFake || poolDummy.isCrypto)) {
+    else if (poolDummy.isMetaFactory && (getPool(poolDummy.basePool).isLending || getPool(poolDummy.basePool).isFake || poolDummy.isCrypto)) {
         if (poolDummy.isCrypto) {
-            Object.assign(Pool.prototype, swapMixins_1.swapCryptoMetaFactoryMixin);
+            Object.assign(Pool.prototype, swapCryptoMetaFactoryMixin);
         }
         else {
-            Object.assign(Pool.prototype, swapMixins_1.swapMetaFactoryMixin);
+            Object.assign(Pool.prototype, swapMetaFactoryMixin);
         }
     }
     else {
-        Object.assign(Pool.prototype, swapMixins_1.swapMixin);
+        Object.assign(Pool.prototype, swapMixin);
     }
     // swapWrapped and swapWrappedEstimateGas
     if (!poolDummy.isPlain && !poolDummy.isFake) {
-        Object.assign(Pool.prototype, swapWrappedMixins_1.swapWrappedExpectedAndApproveMixin);
-        if ('exchange(uint256,uint256,uint256,uint256,bool)' in curve_1.curve.contracts[poolDummy.address].contract) { // tricrypto2 (eth), tricrypto (arbitrum)
-            Object.assign(Pool.prototype, swapWrappedMixins_1.swapWrappedTricrypto2Mixin);
+        Object.assign(Pool.prototype, swapWrappedExpectedAndApproveMixin);
+        if ('exchange(uint256,uint256,uint256,uint256,bool)' in curve.contracts[poolDummy.address].contract) { // tricrypto2 (eth), tricrypto (arbitrum)
+            Object.assign(Pool.prototype, swapWrappedTricrypto2Mixin);
         }
         else {
-            Object.assign(Pool.prototype, swapWrappedMixins_1.swapWrappedMixin);
+            Object.assign(Pool.prototype, swapWrappedMixin);
         }
     }
     return new Pool(poolId);
 };
-exports.getPool = getPool;