@orb-labs/orby-core 0.0.4 → 0.0.6

package/dist/entities/financial/currency_amount.js

@@ -1,99 +1,114 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CurrencyAmount = void 0;
-const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
-const jsbi_1 = __importDefault(require("jsbi"));
-const sdk_core_1 = require("@uniswap/sdk-core");
-const currency_1 = require("./currency");
-const constants_1 = require("../../constants");
+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 __());
+    };
+})();
+import invariant from "tiny-invariant";
+import JSBI from "jsbi";
+import { Fraction, MaxUint256, Rounding } from "@uniswap/sdk-core";
+import { Currency } from "./currency";
+import { Big } from "../../constants";
 // This class is inspired by the Uniswap SDK's (@uniswap/sdk-core) CurrencyAmount class. Created this instance here
 // because we have a need to represent a currency amount that is not a fungible token amount.
-class CurrencyAmount extends sdk_core_1.Fraction {
+var CurrencyAmount = /** @class */ (function (_super) {
+    __extends(CurrencyAmount, _super);
+    function CurrencyAmount(currency, numerator, denominator) {
+        var _this = _super.call(this, numerator.toString(), denominator === null || denominator === void 0 ? void 0 : denominator.toString()) || this;
+        invariant(JSBI.lessThanOrEqual(_this.quotient, MaxUint256), "AMOUNT");
+        _this.currency = currency;
+        _this.decimalScale = JSBI.exponentiate(JSBI.BigInt(10), JSBI.BigInt(currency.decimals));
+        return _this;
+    }
     /**
      * Returns a new currency amount instance from the unitless amount of token, i.e. the raw amount
      * @param currency the currency in the amount
      * @param rawAmount the raw token or ether amount
      */
-    static fromRawAmount(currency, rawAmount) {
+    CurrencyAmount.fromRawAmount = function (currency, rawAmount) {
         return new CurrencyAmount(currency, rawAmount);
-    }
-    static toCurrencyAmount(amount) {
+    };
+    CurrencyAmount.toCurrencyAmount = function (amount) {
         if (!amount) {
             return undefined;
         }
-        const currency = currency_1.Currency.toCurrency(amount.currency);
+        var currency = Currency.toCurrency(amount.currency);
         return CurrencyAmount.fromRawAmount(currency, amount.value);
-    }
+    };
     /**
      * Construct a currency amount with a denominator that is not equal to 1
      * @param currency the currency
      * @param numerator the numerator of the fractional token amount
      * @param denominator the denominator of the fractional token amount
      */
-    static fromFractionalAmount(currency, numerator, denominator) {
+    CurrencyAmount.fromFractionalAmount = function (currency, numerator, denominator) {
         return new CurrencyAmount(currency, numerator, denominator);
-    }
-    constructor(currency, numerator, denominator) {
-        super(numerator.toString(), denominator === null || denominator === void 0 ? void 0 : denominator.toString());
-        (0, tiny_invariant_1.default)(jsbi_1.default.lessThanOrEqual(this.quotient, sdk_core_1.MaxUint256), "AMOUNT");
-        this.currency = currency;
-        this.decimalScale = jsbi_1.default.exponentiate(jsbi_1.default.BigInt(10), jsbi_1.default.BigInt(currency.decimals));
-    }
-    add(other) {
+    };
+    CurrencyAmount.prototype.add = function (other) {
         if (!other) {
             return this;
         }
-        (0, tiny_invariant_1.default)(this.currency.equals(other.currency), "CURRENCY");
-        const added = super.add(other);
+        invariant(this.currency.equals(other.currency), "CURRENCY");
+        var added = _super.prototype.add.call(this, other);
         return CurrencyAmount.fromFractionalAmount(this.currency, added.numerator, added.denominator);
-    }
-    subtract(other) {
-        (0, tiny_invariant_1.default)(this.currency.equals(other.currency), "CURRENCY");
-        const subtracted = super.subtract(other);
+    };
+    CurrencyAmount.prototype.subtract = function (other) {
+        invariant(this.currency.equals(other.currency), "CURRENCY");
+        var subtracted = _super.prototype.subtract.call(this, other);
         return CurrencyAmount.fromFractionalAmount(this.currency, subtracted.numerator, subtracted.denominator);
-    }
-    multiply(other) {
-        const multiplied = super.multiply(other);
+    };
+    CurrencyAmount.prototype.multiply = function (other) {
+        var multiplied = _super.prototype.multiply.call(this, other);
         return CurrencyAmount.fromFractionalAmount(this.currency, multiplied.numerator, multiplied.denominator);
-    }
-    divide(other) {
-        const divided = super.divide(other);
+    };
+    CurrencyAmount.prototype.divide = function (other) {
+        var divided = _super.prototype.divide.call(this, other);
         return CurrencyAmount.fromFractionalAmount(this.currency, divided.numerator, divided.denominator);
-    }
-    cloneWithAmount(amount) {
+    };
+    CurrencyAmount.prototype.cloneWithAmount = function (amount) {
         return CurrencyAmount.fromRawAmount(this.currency, amount);
-    }
-    toRawAmount() {
+    };
+    CurrencyAmount.prototype.toRawAmount = function () {
         return BigInt(this.quotient.toString());
-    }
-    toCurrencyValue(price) {
-        const fraction = price.multiply(this);
-        const denominator = jsbi_1.default.multiply(fraction.denominator, this.decimalScale);
+    };
+    CurrencyAmount.prototype.toCurrencyValue = function (price) {
+        var fraction = price.multiply(this);
+        var denominator = JSBI.multiply(fraction.denominator, this.decimalScale);
         this.amountInFiatCurrency = CurrencyAmount.fromFractionalAmount(price.currency, fraction.numerator, denominator);
         return this.amountInFiatCurrency;
-    }
-    fiatValue() {
+    };
+    CurrencyAmount.prototype.fiatValue = function () {
         return this.amountInFiatCurrency;
-    }
-    toSignificant(significantDigits = 6, format, rounding = sdk_core_1.Rounding.ROUND_DOWN) {
-        return super
-            .divide(this.decimalScale)
+    };
+    CurrencyAmount.prototype.toSignificant = function (significantDigits, format, rounding) {
+        if (significantDigits === void 0) { significantDigits = 6; }
+        if (rounding === void 0) { rounding = Rounding.ROUND_DOWN; }
+        return _super.prototype.divide.call(this, this.decimalScale)
             .toSignificant(significantDigits, format, rounding);
-    }
-    toFixed(decimalPlaces = this.currency.decimals, format, rounding = sdk_core_1.Rounding.ROUND_DOWN) {
-        (0, tiny_invariant_1.default)(decimalPlaces <= this.currency.decimals, "DECIMALS");
-        return super
-            .divide(this.decimalScale)
+    };
+    CurrencyAmount.prototype.toFixed = function (decimalPlaces, format, rounding) {
+        if (decimalPlaces === void 0) { decimalPlaces = this.currency.decimals; }
+        if (rounding === void 0) { rounding = Rounding.ROUND_DOWN; }
+        invariant(decimalPlaces <= this.currency.decimals, "DECIMALS");
+        return _super.prototype.divide.call(this, this.decimalScale)
             .toFixed(decimalPlaces, format, rounding);
-    }
-    toExact(format = { groupSeparator: "" }) {
-        constants_1.Big.DP = this.currency.decimals;
-        return new constants_1.Big(this.quotient.toString())
+    };
+    CurrencyAmount.prototype.toExact = function (format) {
+        if (format === void 0) { format = { groupSeparator: "" }; }
+        Big.DP = this.currency.decimals;
+        return new Big(this.quotient.toString())
             .div(this.decimalScale.toString())
             .toFormat(format);
-    }
-}
-exports.CurrencyAmount = CurrencyAmount;
+    };
+    return CurrencyAmount;
+}(Fraction));
+export { CurrencyAmount };

package/dist/entities/financial/fungible_token.js

@@ -1,20 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FungibleToken = void 0;
-const currency_1 = require("./currency");
-const validateAndParseAddress_1 = require("../../utils/validateAndParseAddress");
-const enums_1 = require("../../enums");
+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 __());
+    };
+})();
+import { Currency } from "./currency";
+import { checkValidAddress, validateAndParseAddress, } from "../../utils/validateAndParseAddress";
+import { TokenType } from "../../enums";
 /**
  * Represents an ERC20 token with a unique address and some metadata.
  */
-class FungibleToken extends currency_1.Currency {
-    static toFungibleToken(token) {
-        if (!token) {
-            return undefined;
-        }
-        const { address, chainId, currency, coinGeckoId, isNative } = token;
-        return new FungibleToken(BigInt(chainId), address, currency.decimals, currency.asset.symbol, currency.asset.name, undefined, isNative, coinGeckoId);
-    }
+var FungibleToken = /** @class */ (function (_super) {
+    __extends(FungibleToken, _super);
     /**
      * @param chainId The chain ID on which this token resides
      * @param address The contract address on the chain on which this token lives
@@ -23,48 +29,57 @@ class FungibleToken extends currency_1.Currency {
      * @param name {@link Currency#name}
      * @param bypassChecksum If true it only checks for length === 42, startsWith 0x and contains only hex characters
      */
-    constructor(chainId, address, decimals, symbol, name, bypassChecksum, isNative, coinGeckoId) {
+    function FungibleToken(chainId, address, decimals, symbol, name, bypassChecksum, isNative, coinGeckoId) {
         // TODO(felix): add this back
         // invariant(!_.isUndefined(getBlockchainFromBlockchainId(chainId)), "CHAIN_ID");
         var _a, _b;
-        super(decimals, symbol, name, undefined, isNative, true, coinGeckoId);
-        this.isToken = true;
+        var _this = _super.call(this, decimals, symbol, name, undefined, isNative, true, coinGeckoId) || this;
+        _this.isToken = true;
         // TODO(felix): bypassChecksum is a little confusing since when bypassChecksum is true, we still validate the address
         // bypassChecksum is derived from the isNative parameter, so we should remove it and just check if isNative here
         if (bypassChecksum) {
-            this.address = (_a = (0, validateAndParseAddress_1.checkValidAddress)(address)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            _this.address = (_a = checkValidAddress(address)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
         }
         else if (!isNative) {
-            this.address = (_b = (0, validateAndParseAddress_1.validateAndParseAddress)(address)) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+            _this.address = (_b = validateAndParseAddress(address)) === null || _b === void 0 ? void 0 : _b.toLowerCase();
         }
         else {
-            this.address = address;
+            _this.address = address;
         }
-        this.isNative = isNative || false;
-        this.chainId = chainId;
+        _this.isNative = isNative || false;
+        _this.chainId = chainId;
+        return _this;
     }
+    FungibleToken.toFungibleToken = function (token) {
+        if (!token) {
+            return undefined;
+        }
+        var address = token.address, chainId = token.chainId, currency = token.currency, coinGeckoId = token.coinGeckoId, isNative = token.isNative;
+        return new FungibleToken(BigInt(chainId), address, currency.decimals, currency.asset.symbol, currency.asset.name, undefined, isNative, coinGeckoId);
+    };
     /**
      * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
      * @param other other token to compare
      */
-    equals(other) {
+    FungibleToken.prototype.equals = function (other) {
         var _a;
         if (this === other)
             return true;
         return (this.chainId == (other === null || other === void 0 ? void 0 : other.chainId) &&
             this.address.toLowerCase() == ((_a = other === null || other === void 0 ? void 0 : other.address) === null || _a === void 0 ? void 0 : _a.toLowerCase()));
-    }
+    };
     /**
      * Returns the currency object that this token represents
      */
-    currency() {
+    FungibleToken.prototype.currency = function () {
         return this;
-    }
-    type() {
-        return enums_1.TokenType.FUNGIBLE_TOKEN;
-    }
-    identifier() {
-        return `${this.chainId}+${this.address.toLowerCase()}`;
-    }
-}
-exports.FungibleToken = FungibleToken;
+    };
+    FungibleToken.prototype.type = function () {
+        return TokenType.FUNGIBLE_TOKEN;
+    };
+    FungibleToken.prototype.identifier = function () {
+        return "".concat(this.chainId, "+").concat(this.address.toLowerCase());
+    };
+    return FungibleToken;
+}(Currency));
+export { FungibleToken };

package/dist/entities/financial/fungible_token_amount.js

@@ -1,102 +1,117 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FungibleTokenAmount = void 0;
-const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
-const jsbi_1 = __importDefault(require("jsbi"));
-const sdk_core_1 = require("@uniswap/sdk-core");
-const fungible_token_1 = require("./fungible_token");
-const currency_amount_1 = require("./currency_amount");
-const constants_1 = require("../../constants");
+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 __());
+    };
+})();
+import invariant from "tiny-invariant";
+import JSBI from "jsbi";
+import { Fraction, Rounding, MaxUint256 } from "@uniswap/sdk-core";
+import { FungibleToken } from "./fungible_token";
+import { CurrencyAmount } from "./currency_amount";
+import { Big } from "../../constants";
 // This class is inspired by the Uniswap SDK's (@uniswap/sdk-core) CurrencyAmount class. Created this instance here
 // because we have a need to represent a currency amount that is not a fungible token amount.
-class FungibleTokenAmount extends sdk_core_1.Fraction {
+var FungibleTokenAmount = /** @class */ (function (_super) {
+    __extends(FungibleTokenAmount, _super);
+    function FungibleTokenAmount(fungibleToken, numerator, denominator, amountInFiatCurrency) {
+        var _this = _super.call(this, numerator.toString(), denominator === null || denominator === void 0 ? void 0 : denominator.toString()) || this;
+        invariant(JSBI.lessThanOrEqual(_this.quotient, MaxUint256), "AMOUNT");
+        _this.token = fungibleToken;
+        _this.decimalScale = JSBI.exponentiate(JSBI.BigInt(10), JSBI.BigInt(fungibleToken.decimals));
+        _this.amountInFiatCurrency = amountInFiatCurrency;
+        return _this;
+    }
     /**
      * Returns a new fungibleToken amount instance from the unitless amount of token, i.e. the raw amount
      * @param fungibleToken the fungibleToken in the amount
      * @param rawAmount the raw token or ether amount
      */
-    static fromRawAmount(fungibleToken, rawAmount, amountInFiatCurrency) {
+    FungibleTokenAmount.fromRawAmount = function (fungibleToken, rawAmount, amountInFiatCurrency) {
         return new FungibleTokenAmount(fungibleToken, rawAmount, undefined, amountInFiatCurrency);
-    }
+    };
     /**
      * Construct a fungibleToken amount with a denominator that is not equal to 1
      * @param fungibleToken the fungibleToken
      * @param numerator the numerator of the fractional token amount
      * @param denominator the denominator of the fractional token amount
      */
-    static fromFractionalAmount(fungibleToken, numerator, denominator, amountInFiatCurrency) {
+    FungibleTokenAmount.fromFractionalAmount = function (fungibleToken, numerator, denominator, amountInFiatCurrency) {
         return new FungibleTokenAmount(fungibleToken, numerator, denominator, amountInFiatCurrency);
-    }
-    static toFungibleTokenAmount(amount) {
+    };
+    FungibleTokenAmount.toFungibleTokenAmount = function (amount) {
         if (!amount) {
             return undefined;
         }
-        const amountInFiatCurrency = currency_amount_1.CurrencyAmount.toCurrencyAmount(amount.amountInFiatCurrency);
-        return FungibleTokenAmount.fromRawAmount(fungible_token_1.FungibleToken.toFungibleToken(amount.token), amount.value, amountInFiatCurrency);
-    }
-    constructor(fungibleToken, numerator, denominator, amountInFiatCurrency) {
-        super(numerator.toString(), denominator === null || denominator === void 0 ? void 0 : denominator.toString());
-        (0, tiny_invariant_1.default)(jsbi_1.default.lessThanOrEqual(this.quotient, sdk_core_1.MaxUint256), "AMOUNT");
-        this.token = fungibleToken;
-        this.decimalScale = jsbi_1.default.exponentiate(jsbi_1.default.BigInt(10), jsbi_1.default.BigInt(fungibleToken.decimals));
-        this.amountInFiatCurrency = amountInFiatCurrency;
-    }
-    equals(other) {
+        var amountInFiatCurrency = CurrencyAmount.toCurrencyAmount(amount.amountInFiatCurrency);
+        return FungibleTokenAmount.fromRawAmount(FungibleToken.toFungibleToken(amount.token), amount.value, amountInFiatCurrency);
+    };
+    FungibleTokenAmount.prototype.equals = function (other) {
         return (this.token.equals(other.token) &&
             this.toRawAmount() == other.toRawAmount());
-    }
-    add(other) {
-        (0, tiny_invariant_1.default)(this.token.equals(other.token), "FUNGIBLE_TOKEN");
-        const added = super.add(other);
+    };
+    FungibleTokenAmount.prototype.add = function (other) {
+        invariant(this.token.equals(other.token), "FUNGIBLE_TOKEN");
+        var added = _super.prototype.add.call(this, other);
         return FungibleTokenAmount.fromFractionalAmount(this.token, added.numerator, added.denominator);
-    }
-    subtract(other) {
-        (0, tiny_invariant_1.default)(this.token.equals(other.token), "FUNGIBLE_TOKEN");
-        const subtracted = super.subtract(other);
+    };
+    FungibleTokenAmount.prototype.subtract = function (other) {
+        invariant(this.token.equals(other.token), "FUNGIBLE_TOKEN");
+        var subtracted = _super.prototype.subtract.call(this, other);
         return FungibleTokenAmount.fromFractionalAmount(this.token, subtracted.numerator, subtracted.denominator);
-    }
-    multiply(other) {
-        const multiplied = super.multiply(other);
+    };
+    FungibleTokenAmount.prototype.multiply = function (other) {
+        var multiplied = _super.prototype.multiply.call(this, other);
         return FungibleTokenAmount.fromFractionalAmount(this.token, multiplied.numerator, multiplied.denominator);
-    }
-    divide(other) {
-        const divided = super.divide(other);
+    };
+    FungibleTokenAmount.prototype.divide = function (other) {
+        var divided = _super.prototype.divide.call(this, other);
         return FungibleTokenAmount.fromFractionalAmount(this.token, divided.numerator, divided.denominator);
-    }
-    greaterThanOrEqual(other) {
+    };
+    FungibleTokenAmount.prototype.greaterThanOrEqual = function (other) {
         return this.greaterThan(other) || this.equals(other);
-    }
-    toRawAmount() {
+    };
+    FungibleTokenAmount.prototype.toRawAmount = function () {
         return BigInt(this.quotient.toString());
-    }
-    fiatValue() {
+    };
+    FungibleTokenAmount.prototype.fiatValue = function () {
         return this.amountInFiatCurrency;
-    }
-    toCurrencyValue(price) {
-        const fraction = price.multiply(this);
-        const denominator = jsbi_1.default.multiply(fraction.denominator, this.decimalScale);
-        this.amountInFiatCurrency = currency_amount_1.CurrencyAmount.fromFractionalAmount(price.currency, fraction.numerator, denominator);
+    };
+    FungibleTokenAmount.prototype.toCurrencyValue = function (price) {
+        var fraction = price.multiply(this);
+        var denominator = JSBI.multiply(fraction.denominator, this.decimalScale);
+        this.amountInFiatCurrency = CurrencyAmount.fromFractionalAmount(price.currency, fraction.numerator, denominator);
         return this.amountInFiatCurrency;
-    }
-    toSignificant(significantDigits = 6, format, rounding = sdk_core_1.Rounding.ROUND_DOWN) {
-        return super
-            .divide(this.decimalScale)
+    };
+    FungibleTokenAmount.prototype.toSignificant = function (significantDigits, format, rounding) {
+        if (significantDigits === void 0) { significantDigits = 6; }
+        if (rounding === void 0) { rounding = Rounding.ROUND_DOWN; }
+        return _super.prototype.divide.call(this, this.decimalScale)
             .toSignificant(significantDigits, format, rounding);
-    }
-    toFixed(decimalPlaces = this.token.decimals, format, rounding = sdk_core_1.Rounding.ROUND_DOWN) {
-        (0, tiny_invariant_1.default)(decimalPlaces <= this.token.decimals, "DECIMALS");
-        return super
-            .divide(this.decimalScale)
+    };
+    FungibleTokenAmount.prototype.toFixed = function (decimalPlaces, format, rounding) {
+        if (decimalPlaces === void 0) { decimalPlaces = this.token.decimals; }
+        if (rounding === void 0) { rounding = Rounding.ROUND_DOWN; }
+        invariant(decimalPlaces <= this.token.decimals, "DECIMALS");
+        return _super.prototype.divide.call(this, this.decimalScale)
             .toFixed(decimalPlaces, format, rounding);
-    }
-    toExact(format = { groupSeparator: "" }) {
-        constants_1.Big.DP = this.token.decimals;
-        return new constants_1.Big(this.quotient.toString())
+    };
+    FungibleTokenAmount.prototype.toExact = function (format) {
+        if (format === void 0) { format = { groupSeparator: "" }; }
+        Big.DP = this.token.decimals;
+        return new Big(this.quotient.toString())
             .div(this.decimalScale.toString())
             .toFormat(format);
-    }
-}
-exports.FungibleTokenAmount = FungibleTokenAmount;
+    };
+    return FungibleTokenAmount;
+}(Fraction));
+export { FungibleTokenAmount };

package/dist/entities/financial/non_fungible_token.js

@@ -1,13 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NonFungibleToken = void 0;
-const asset_1 = require("./asset");
-const validateAndParseAddress_1 = require("../../utils/validateAndParseAddress");
-const enums_1 = require("../../enums");
+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 __());
+    };
+})();
+import { Asset } from "./asset";
+import { checkValidAddress, validateAndParseAddress, } from "../../utils/validateAndParseAddress";
+import { TokenType } from "../../enums";
 /**
  * Represents an ERC721 token with a unique address and some metadata.
  */
-class NonFungibleToken extends asset_1.Asset {
+var NonFungibleToken = /** @class */ (function (_super) {
+    __extends(NonFungibleToken, _super);
     /**
      * @param chainId The chain ID on which this token resides
      * @param address The contract address on the chain on which this token lives
@@ -16,51 +29,53 @@ class NonFungibleToken extends asset_1.Asset {
      * @param url The URL of the token's metadata
      * @param bypassChecksum If true it only checks for length === 42, startsWith 0x and contains only hex characters
      */
-    constructor(chainId, address, symbol, name, url, bypassChecksum, coinGeckoId) {
+    function NonFungibleToken(chainId, address, symbol, name, url, bypassChecksum, coinGeckoId) {
         // TODO(felix): add this back
         // invariant(!_.isUndefined(getBlockchainFromBlockchainId(chainId)), "CHAIN_ID");
         var _a, _b;
-        super(symbol, name, coinGeckoId);
-        this.isNative = false;
-        this.isToken = true;
+        var _this = _super.call(this, symbol, name, coinGeckoId) || this;
+        _this.isNative = false;
+        _this.isToken = true;
         if (bypassChecksum) {
-            this.address = (_a = (0, validateAndParseAddress_1.checkValidAddress)(address)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            _this.address = (_a = checkValidAddress(address)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
         }
         else {
-            this.address = (_b = (0, validateAndParseAddress_1.validateAndParseAddress)(address)) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+            _this.address = (_b = validateAndParseAddress(address)) === null || _b === void 0 ? void 0 : _b.toLowerCase();
         }
-        this.chainId = chainId;
-        this.url = url;
+        _this.chainId = chainId;
+        _this.url = url;
+        return _this;
     }
-    static toNonFungibleToken(nft) {
+    NonFungibleToken.toNonFungibleToken = function (nft) {
         if (!nft) {
             return undefined;
         }
-        const asset = asset_1.Asset.toAsset(nft.asset);
+        var asset = Asset.toAsset(nft.asset);
         return new NonFungibleToken(nft.chainId, nft.address, asset.symbol, asset.name, nft.url);
-    }
+    };
     /**
      * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
      * @param other other token to compare
      */
-    equals(other) {
+    NonFungibleToken.prototype.equals = function (other) {
         // short circuit on reference equality
         if (this === other)
             return true;
         return (this.chainId === other.chainId &&
             this.address === other.address.toLowerCase());
-    }
+    };
     /**
      * Returns the asset representation of this currency
      */
-    asset() {
+    NonFungibleToken.prototype.asset = function () {
         return this;
-    }
-    type() {
-        return enums_1.TokenType.NON_FUNGIBLE_TOKEN;
-    }
-    identifier() {
-        return `${this.chainId}+${this.address.toLowerCase()}`;
-    }
-}
-exports.NonFungibleToken = NonFungibleToken;
+    };
+    NonFungibleToken.prototype.type = function () {
+        return TokenType.NON_FUNGIBLE_TOKEN;
+    };
+    NonFungibleToken.prototype.identifier = function () {
+        return "".concat(this.chainId, "+").concat(this.address.toLowerCase());
+    };
+    return NonFungibleToken;
+}(Asset));
+export { NonFungibleToken };