@orb-labs/orby-core 0.0.6 → 0.0.8

package/dist/entities/financial/currency.js

@@ -1,27 +1,11 @@
-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 { Asset } from "./asset";
+import { Asset } from "./asset.js";
 // This class is inspired by the Uniswap SDK's (@uniswap/sdk-core) CurrencyAmount class. Create this instance here
 // because we represent currency amounts that are not fungible token amounts.
 /**
  * A currency is any fungible financial instrument, including Ether, all ERC20 tokens, and other chain-native currencies
  */
-var Currency = /** @class */ (function (_super) {
-    __extends(Currency, _super);
+export class Currency extends Asset {
     /**
      * Constructs an instance of the base class `Currency`.
      * @param decimals decimals of the currency
@@ -30,39 +14,36 @@ var Currency = /** @class */ (function (_super) {
      * @param isNative whether the currency is native to the chain and must be wrapped (e.g. Ether)
      * @param isToken whether the currency is a token that is usable in Uniswap without wrapping
      */
-    function Currency(decimals, symbol, name, logoUrl, isNative, isToken, coinGeckoId) {
-        var _this = _super.call(this, symbol, name, coinGeckoId) || this;
+    constructor(decimals, symbol, name, logoUrl, isNative, isToken, coinGeckoId) {
+        super(symbol, name, coinGeckoId);
         invariant(decimals >= 0 && decimals < 255 && Number.isInteger(decimals), "DECIMALS");
-        _this.decimals = decimals;
-        _this.isNative = isNative !== null && isNative !== void 0 ? isNative : false;
-        _this.isToken = isToken !== null && isToken !== void 0 ? isToken : true;
-        _this.logoUrl = logoUrl;
-        return _this;
+        this.decimals = decimals;
+        this.isNative = isNative ?? false;
+        this.isToken = isToken ?? true;
+        this.logoUrl = logoUrl;
     }
     /**
      * Returns whether this currency is functionally equivalent to the other currency
      * @param other the other currency
      */
-    Currency.prototype.equals = function (other) {
+    equals(other) {
         if (this === other)
             return true;
         return (this.symbol === other.symbol &&
             this.name === other.name &&
             this.decimals === other.decimals);
-    };
+    }
     /**
      * Returns the asset representation of this currency
      */
-    Currency.prototype.asset = function () {
+    asset() {
         return this;
-    };
-    Currency.toCurrency = function (currency) {
+    }
+    static toCurrency(currency) {
         if (!currency) {
             return undefined;
         }
-        var asset = currency.asset, decimals = currency.decimals, logoUrl = currency.logoUrl, isNative = currency.isNative;
+        const { asset, decimals, logoUrl, isNative } = currency;
         return new Currency(decimals, asset.symbol, asset.name, logoUrl, isNative);
-    };
-    return Currency;
-}(Asset));
-export { Currency };
+    }
+}

package/dist/entities/financial/currency_amount.d.ts

@@ -1,6 +1,6 @@
 import JSBI from "jsbi";
 import { Fraction, BigintIsh, Rounding } from "@uniswap/sdk-core";
-import { Currency } from "./currency";
+import { Currency } from "./currency.js";
 export declare class CurrencyAmount extends Fraction {
     readonly currency: Currency;
     readonly decimalScale: JSBI;

package/dist/entities/financial/currency_amount.js

@@ -1,114 +1,92 @@
-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";
+import { Currency } from "./currency.js";
+import { Big } from "../../constants.js";
 // 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.
-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;
-    }
+export class CurrencyAmount extends Fraction {
     /**
      * 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
      */
-    CurrencyAmount.fromRawAmount = function (currency, rawAmount) {
+    static fromRawAmount(currency, rawAmount) {
         return new CurrencyAmount(currency, rawAmount);
-    };
-    CurrencyAmount.toCurrencyAmount = function (amount) {
+    }
+    static toCurrencyAmount(amount) {
         if (!amount) {
             return undefined;
         }
-        var currency = Currency.toCurrency(amount.currency);
+        const 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
      */
-    CurrencyAmount.fromFractionalAmount = function (currency, numerator, denominator) {
+    static fromFractionalAmount(currency, numerator, denominator) {
         return new CurrencyAmount(currency, numerator, denominator);
-    };
-    CurrencyAmount.prototype.add = function (other) {
+    }
+    constructor(currency, numerator, denominator) {
+        super(numerator.toString(), denominator?.toString());
+        invariant(JSBI.lessThanOrEqual(this.quotient, MaxUint256), "AMOUNT");
+        this.currency = currency;
+        this.decimalScale = JSBI.exponentiate(JSBI.BigInt(10), JSBI.BigInt(currency.decimals));
+    }
+    add(other) {
         if (!other) {
             return this;
         }
         invariant(this.currency.equals(other.currency), "CURRENCY");
-        var added = _super.prototype.add.call(this, other);
+        const added = super.add(other);
         return CurrencyAmount.fromFractionalAmount(this.currency, added.numerator, added.denominator);
-    };
-    CurrencyAmount.prototype.subtract = function (other) {
+    }
+    subtract(other) {
         invariant(this.currency.equals(other.currency), "CURRENCY");
-        var subtracted = _super.prototype.subtract.call(this, other);
+        const subtracted = super.subtract(other);
         return CurrencyAmount.fromFractionalAmount(this.currency, subtracted.numerator, subtracted.denominator);
-    };
-    CurrencyAmount.prototype.multiply = function (other) {
-        var multiplied = _super.prototype.multiply.call(this, other);
+    }
+    multiply(other) {
+        const multiplied = super.multiply(other);
         return CurrencyAmount.fromFractionalAmount(this.currency, multiplied.numerator, multiplied.denominator);
-    };
-    CurrencyAmount.prototype.divide = function (other) {
-        var divided = _super.prototype.divide.call(this, other);
+    }
+    divide(other) {
+        const divided = super.divide(other);
         return CurrencyAmount.fromFractionalAmount(this.currency, divided.numerator, divided.denominator);
-    };
-    CurrencyAmount.prototype.cloneWithAmount = function (amount) {
+    }
+    cloneWithAmount(amount) {
         return CurrencyAmount.fromRawAmount(this.currency, amount);
-    };
-    CurrencyAmount.prototype.toRawAmount = function () {
+    }
+    toRawAmount() {
         return BigInt(this.quotient.toString());
-    };
-    CurrencyAmount.prototype.toCurrencyValue = function (price) {
-        var fraction = price.multiply(this);
-        var denominator = JSBI.multiply(fraction.denominator, this.decimalScale);
+    }
+    toCurrencyValue(price) {
+        const fraction = price.multiply(this);
+        const denominator = JSBI.multiply(fraction.denominator, this.decimalScale);
         this.amountInFiatCurrency = CurrencyAmount.fromFractionalAmount(price.currency, fraction.numerator, denominator);
         return this.amountInFiatCurrency;
-    };
-    CurrencyAmount.prototype.fiatValue = function () {
+    }
+    fiatValue() {
         return this.amountInFiatCurrency;
-    };
-    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 = 6, format, rounding = Rounding.ROUND_DOWN) {
+        return super
+            .divide(this.decimalScale)
             .toSignificant(significantDigits, format, rounding);
-    };
-    CurrencyAmount.prototype.toFixed = function (decimalPlaces, format, rounding) {
-        if (decimalPlaces === void 0) { decimalPlaces = this.currency.decimals; }
-        if (rounding === void 0) { rounding = Rounding.ROUND_DOWN; }
+    }
+    toFixed(decimalPlaces = this.currency.decimals, format, rounding = Rounding.ROUND_DOWN) {
         invariant(decimalPlaces <= this.currency.decimals, "DECIMALS");
-        return _super.prototype.divide.call(this, this.decimalScale)
+        return super
+            .divide(this.decimalScale)
             .toFixed(decimalPlaces, format, rounding);
-    };
-    CurrencyAmount.prototype.toExact = function (format) {
-        if (format === void 0) { format = { groupSeparator: "" }; }
+    }
+    toExact(format = { groupSeparator: "" }) {
         Big.DP = this.currency.decimals;
         return new Big(this.quotient.toString())
             .div(this.decimalScale.toString())
             .toFormat(format);
-    };
-    return CurrencyAmount;
-}(Fraction));
-export { CurrencyAmount };
+    }
+}

package/dist/entities/financial/fungible_token.d.ts

@@ -1,5 +1,5 @@
-import { Currency } from "./currency";
-import { TokenType } from "../../enums";
+import { Currency } from "./currency.js";
+import { TokenType } from "../../enums.js";
 /**
  * Represents an ERC20 token with a unique address and some metadata.
  */
@@ -26,7 +26,7 @@ export declare class FungibleToken extends 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: bigint, address: string, decimals: number, symbol: string, name: string, bypassChecksum?: boolean, isNative?: boolean, coinGeckoId?: string);
+    constructor(chainId: bigint, address: string, decimals: number, symbol: string, name: string, bypassChecksum?: boolean, isNative?: boolean, coinGeckoId?: string, logoUrl?: string);
     /**
      * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
      * @param other other token to compare

package/dist/entities/financial/fungible_token.js

@@ -1,26 +1,17 @@
-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";
+import { Currency } from "./currency.js";
+import { checkValidAddress, validateAndParseAddress, } from "../../utils/validateAndParseAddress.js";
+import { TokenType } from "../../enums.js";
 /**
  * Represents an ERC20 token with a unique address and some metadata.
  */
-var FungibleToken = /** @class */ (function (_super) {
-    __extends(FungibleToken, _super);
+export class FungibleToken extends 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);
+    }
     /**
      * @param chainId The chain ID on which this token resides
      * @param address The contract address on the chain on which this token lives
@@ -29,57 +20,45 @@ var FungibleToken = /** @class */ (function (_super) {
      * @param name {@link Currency#name}
      * @param bypassChecksum If true it only checks for length === 42, startsWith 0x and contains only hex characters
      */
-    function FungibleToken(chainId, address, decimals, symbol, name, bypassChecksum, isNative, coinGeckoId) {
+    constructor(chainId, address, decimals, symbol, name, bypassChecksum, isNative, coinGeckoId, logoUrl) {
         // TODO(felix): add this back
         // invariant(!_.isUndefined(getBlockchainFromBlockchainId(chainId)), "CHAIN_ID");
-        var _a, _b;
-        var _this = _super.call(this, decimals, symbol, name, undefined, isNative, true, coinGeckoId) || this;
-        _this.isToken = true;
+        super(decimals, symbol, name, logoUrl, isNative, true, coinGeckoId);
+        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 = checkValidAddress(address)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            this.address = checkValidAddress(address)?.toLowerCase();
         }
         else if (!isNative) {
-            _this.address = (_b = validateAndParseAddress(address)) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+            this.address = validateAndParseAddress(address)?.toLowerCase();
         }
         else {
-            _this.address = address;
+            this.address = address;
         }
-        _this.isNative = isNative || false;
-        _this.chainId = chainId;
-        return _this;
+        this.isNative = isNative || false;
+        this.chainId = chainId;
     }
-    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
      */
-    FungibleToken.prototype.equals = function (other) {
-        var _a;
+    equals(other) {
         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()));
-    };
+        return (this.chainId == other?.chainId &&
+            this.address.toLowerCase() == other?.address?.toLowerCase());
+    }
     /**
      * Returns the currency object that this token represents
      */
-    FungibleToken.prototype.currency = function () {
+    currency() {
         return this;
-    };
-    FungibleToken.prototype.type = function () {
+    }
+    type() {
         return TokenType.FUNGIBLE_TOKEN;
-    };
-    FungibleToken.prototype.identifier = function () {
-        return "".concat(this.chainId, "+").concat(this.address.toLowerCase());
-    };
-    return FungibleToken;
-}(Currency));
-export { FungibleToken };
+    }
+    identifier() {
+        return `${this.chainId}+${this.address.toLowerCase()}`;
+    }
+}

package/dist/entities/financial/fungible_token_amount.d.ts

@@ -1,7 +1,7 @@
 import JSBI from "jsbi";
 import { Fraction, BigintIsh, Rounding } from "@uniswap/sdk-core";
-import { FungibleToken } from "./fungible_token";
-import { CurrencyAmount } from "./currency_amount";
+import { FungibleToken } from "./fungible_token.js";
+import { CurrencyAmount } from "./currency_amount.js";
 export declare class FungibleTokenAmount extends Fraction {
     readonly token: FungibleToken;
     readonly decimalScale: JSBI;

package/dist/entities/financial/fungible_token_amount.js

@@ -1,117 +1,95 @@
-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";
+import { FungibleToken } from "./fungible_token.js";
+import { CurrencyAmount } from "./currency_amount.js";
+import { Big } from "../../constants.js";
 // 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.
-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;
-    }
+export class FungibleTokenAmount extends Fraction {
     /**
      * 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
      */
-    FungibleTokenAmount.fromRawAmount = function (fungibleToken, rawAmount, amountInFiatCurrency) {
+    static fromRawAmount(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
      */
-    FungibleTokenAmount.fromFractionalAmount = function (fungibleToken, numerator, denominator, amountInFiatCurrency) {
+    static fromFractionalAmount(fungibleToken, numerator, denominator, amountInFiatCurrency) {
         return new FungibleTokenAmount(fungibleToken, numerator, denominator, amountInFiatCurrency);
-    };
-    FungibleTokenAmount.toFungibleTokenAmount = function (amount) {
+    }
+    static toFungibleTokenAmount(amount) {
         if (!amount) {
             return undefined;
         }
-        var amountInFiatCurrency = CurrencyAmount.toCurrencyAmount(amount.amountInFiatCurrency);
+        const amountInFiatCurrency = CurrencyAmount.toCurrencyAmount(amount.amountInFiatCurrency);
         return FungibleTokenAmount.fromRawAmount(FungibleToken.toFungibleToken(amount.token), amount.value, amountInFiatCurrency);
-    };
-    FungibleTokenAmount.prototype.equals = function (other) {
+    }
+    constructor(fungibleToken, numerator, denominator, amountInFiatCurrency) {
+        super(numerator.toString(), denominator?.toString());
+        invariant(JSBI.lessThanOrEqual(this.quotient, MaxUint256), "AMOUNT"); // TODO(imti): fix this
+        this.token = fungibleToken;
+        this.decimalScale = JSBI.exponentiate(JSBI.BigInt(10), JSBI.BigInt(fungibleToken.decimals));
+        this.amountInFiatCurrency = amountInFiatCurrency;
+    }
+    equals(other) {
         return (this.token.equals(other.token) &&
             this.toRawAmount() == other.toRawAmount());
-    };
-    FungibleTokenAmount.prototype.add = function (other) {
+    }
+    add(other) {
         invariant(this.token.equals(other.token), "FUNGIBLE_TOKEN");
-        var added = _super.prototype.add.call(this, other);
+        const added = super.add(other);
         return FungibleTokenAmount.fromFractionalAmount(this.token, added.numerator, added.denominator);
-    };
-    FungibleTokenAmount.prototype.subtract = function (other) {
+    }
+    subtract(other) {
         invariant(this.token.equals(other.token), "FUNGIBLE_TOKEN");
-        var subtracted = _super.prototype.subtract.call(this, other);
+        const subtracted = super.subtract(other);
         return FungibleTokenAmount.fromFractionalAmount(this.token, subtracted.numerator, subtracted.denominator);
-    };
-    FungibleTokenAmount.prototype.multiply = function (other) {
-        var multiplied = _super.prototype.multiply.call(this, other);
+    }
+    multiply(other) {
+        const multiplied = super.multiply(other);
         return FungibleTokenAmount.fromFractionalAmount(this.token, multiplied.numerator, multiplied.denominator);
-    };
-    FungibleTokenAmount.prototype.divide = function (other) {
-        var divided = _super.prototype.divide.call(this, other);
+    }
+    divide(other) {
+        const divided = super.divide(other);
         return FungibleTokenAmount.fromFractionalAmount(this.token, divided.numerator, divided.denominator);
-    };
-    FungibleTokenAmount.prototype.greaterThanOrEqual = function (other) {
+    }
+    greaterThanOrEqual(other) {
         return this.greaterThan(other) || this.equals(other);
-    };
-    FungibleTokenAmount.prototype.toRawAmount = function () {
+    }
+    toRawAmount() {
         return BigInt(this.quotient.toString());
-    };
-    FungibleTokenAmount.prototype.fiatValue = function () {
+    }
+    fiatValue() {
         return this.amountInFiatCurrency;
-    };
-    FungibleTokenAmount.prototype.toCurrencyValue = function (price) {
-        var fraction = price.multiply(this);
-        var denominator = JSBI.multiply(fraction.denominator, this.decimalScale);
+    }
+    toCurrencyValue(price) {
+        const fraction = price.multiply(this);
+        const denominator = JSBI.multiply(fraction.denominator, this.decimalScale);
         this.amountInFiatCurrency = CurrencyAmount.fromFractionalAmount(price.currency, fraction.numerator, denominator);
         return this.amountInFiatCurrency;
-    };
-    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 = 6, format, rounding = Rounding.ROUND_DOWN) {
+        return super
+            .divide(this.decimalScale)
             .toSignificant(significantDigits, format, rounding);
-    };
-    FungibleTokenAmount.prototype.toFixed = function (decimalPlaces, format, rounding) {
-        if (decimalPlaces === void 0) { decimalPlaces = this.token.decimals; }
-        if (rounding === void 0) { rounding = Rounding.ROUND_DOWN; }
+    }
+    toFixed(decimalPlaces = this.token.decimals, format, rounding = Rounding.ROUND_DOWN) {
         invariant(decimalPlaces <= this.token.decimals, "DECIMALS");
-        return _super.prototype.divide.call(this, this.decimalScale)
+        return super
+            .divide(this.decimalScale)
             .toFixed(decimalPlaces, format, rounding);
-    };
-    FungibleTokenAmount.prototype.toExact = function (format) {
-        if (format === void 0) { format = { groupSeparator: "" }; }
+    }
+    toExact(format = { groupSeparator: "" }) {
         Big.DP = this.token.decimals;
         return new Big(this.quotient.toString())
             .div(this.decimalScale.toString())
             .toFormat(format);
-    };
-    return FungibleTokenAmount;
-}(Fraction));
-export { FungibleTokenAmount };
+    }
+}

package/dist/entities/financial/non_fungible_token.d.ts

@@ -1,5 +1,5 @@
-import { Asset } from "./asset";
-import { TokenType } from "../../enums";
+import { Asset } from "./asset.js";
+import { TokenType } from "../../enums.js";
 /**
  * Represents an ERC721 token with a unique address and some metadata.
  */