@orb-labs/orby-core 0.0.13 → 0.0.15

package/dist/esm/entities/account.js

@@ -0,0 +1,45 @@
+import { AccountType } from "../enums.js";
+import { getChainIdFromOrbyChainId } from "../utils/utils.js";
+export class Account {
+    static toAccount(account) {
+        const chainId = account?.chainId
+            ? getChainIdFromOrbyChainId(account.chainId)
+            : undefined;
+        const formattedAccountType = account?.accountType?.toLowerCase();
+        if (!chainId && formattedAccountType == AccountType.SCA) {
+            return undefined;
+        }
+        return new Account(account.address, formattedAccountType, account.vmType, chainId);
+    }
+    constructor(address, accountType, vmType, chainId) {
+        // TODO(felix): add this back
+        // invariant(!_.isUndefined(getBlockchainFromBlockchainId(chainId)), "CHAIN_ID");
+        this.address = address?.toLowerCase(); // validateAndParseAddress(address)?.toLowerCase();
+        this.chainId = chainId ? BigInt(chainId) : undefined;
+        this.accountType = accountType;
+        this.vmType = vmType;
+        this.key = Account.key(address, chainId);
+        if (this.accountType == AccountType.SCA) {
+            this.hasSufficientBalanceForGas = true;
+        }
+        else {
+            this.hasSufficientBalanceForGas = false;
+        }
+    }
+    static key(address, chainId) {
+        return chainId
+            ? `${chainId?.toString()?.toLowerCase()}-${address}`
+            : address;
+    }
+    toAccountModel() {
+        return {
+            address: this.address,
+            accountType: this.accountType?.toUpperCase(),
+            vmType: this.vmType?.toUpperCase(),
+            chainId: this.chainId ? "EIP155-" + this.chainId : undefined,
+        };
+    }
+    equals(other) {
+        return this.key == other?.key && this.accountType == other?.accountType;
+    }
+}

package/dist/esm/entities/financial/account_balance.d.ts

@@ -0,0 +1,12 @@
+import { Account } from "../account.js";
+import { FungibleTokenAmount } from "./fungible_token_amount.js";
+export declare class AccountBalance {
+    readonly amount: FungibleTokenAmount;
+    readonly account: Account;
+    static toAccountBalance(balance?: any): AccountBalance;
+    constructor(amount: FungibleTokenAmount, account: Account);
+    equals(other: AccountBalance): boolean;
+    lessThan(other: AccountBalance): boolean;
+    greaterThan(other: AccountBalance): boolean;
+    greaterThanOrEqual(other: AccountBalance): boolean;
+}

package/dist/esm/entities/financial/account_balance.js

@@ -0,0 +1,31 @@
+import { Account } from "../account.js";
+import { FungibleTokenAmount } from "./fungible_token_amount.js";
+export class AccountBalance {
+    static toAccountBalance(balance) {
+        if (!balance) {
+            return undefined;
+        }
+        const amount = FungibleTokenAmount.toFungibleTokenAmount(balance.amount);
+        const account = Account.toAccount(balance.account);
+        return new AccountBalance(amount, account);
+    }
+    constructor(amount, account) {
+        this.amount = amount;
+        this.account = account;
+    }
+    equals(other) {
+        return (this.account.equals(other.account) && this.amount.equals(other.amount));
+    }
+    lessThan(other) {
+        return (this.account.equals(other.account) && this.amount.lessThan(other.amount));
+    }
+    greaterThan(other) {
+        return (this.account.equals(other.account) &&
+            this.amount.greaterThan(other.amount));
+    }
+    greaterThanOrEqual(other) {
+        return (this.account.equals(other.account) &&
+            (this.amount.greaterThan(other.amount) ||
+                this.amount.equals(other.amount)));
+    }
+}

package/dist/esm/entities/financial/asset.d.ts

@@ -0,0 +1,31 @@
+/**
+ * An Asset is any fungible financial instrument, including Ether, all ERC20 tokens, and NFTs
+ */
+export declare class Asset {
+    /**
+     * The symbol of the asset, i.e. a short textual non-unique identifier
+     */
+    readonly symbol: string;
+    /**
+     * The name of the asset, i.e. a descriptive textual non-unique identifier
+     */
+    readonly name: string;
+    /**
+     * The name of the asset, i.e. a descriptive textual non-unique identifier
+     */
+    readonly coinGeckoId: string;
+    /**
+     * Constructs an instance of the `Asset`.
+     * @param symbol symbol of the asset
+     * @param name of the asset
+     */
+    constructor(symbol: string, name: string, coinGeckoId?: string);
+    /**
+     * Returns whether this asset is functionally equivalent to the other asset
+     * @param other the other asset
+     */
+    equals(other: Asset): boolean;
+    toAssetModel(): any;
+    static toAsset(asset?: any): Asset;
+    id(): string;
+}

package/dist/esm/entities/financial/asset.js

@@ -0,0 +1,38 @@
+/**
+ * An Asset is any fungible financial instrument, including Ether, all ERC20 tokens, and NFTs
+ */
+export class Asset {
+    /**
+     * Constructs an instance of the `Asset`.
+     * @param symbol symbol of the asset
+     * @param name of the asset
+     */
+    constructor(symbol, name, coinGeckoId) {
+        this.symbol = symbol;
+        this.name = name;
+        this.coinGeckoId = coinGeckoId;
+    }
+    /**
+     * Returns whether this asset is functionally equivalent to the other asset
+     * @param other the other asset
+     */
+    equals(other) {
+        if (this === other)
+            return true;
+        return this.symbol === other.symbol && this.name === other.name;
+    }
+    // return Asset in the "@domains/orby/src/api/graphql/generated" but could not set type here because the generated code is not available for other domains
+    toAssetModel() {
+        return { symbol: this.symbol, name: this.name };
+    }
+    static toAsset(asset) {
+        if (!asset) {
+            return undefined;
+        }
+        const { symbol, name } = asset;
+        return new Asset(symbol, name);
+    }
+    id() {
+        return `${this.name}:${this.symbol}`;
+    }
+}

package/dist/esm/entities/financial/currency.d.ts

@@ -0,0 +1,41 @@
+import { Asset } from "./asset.js";
+/**
+ * A currency is any fungible financial instrument, including Ether, all ERC20 tokens, and other chain-native currencies
+ */
+export declare class Currency extends Asset {
+    /**
+     * Returns whether the currency is native to the chain and must be wrapped (e.g. Ether)
+     */
+    readonly isNative: boolean;
+    /**
+     * Returns whether the currency is a token that is usable in Uniswap without wrapping
+     */
+    readonly isToken: boolean;
+    /**
+     * The decimals used in representing currency amounts
+     */
+    readonly decimals: number;
+    /**
+     * The url for the currency logo
+     */
+    readonly logoUrl?: string;
+    /**
+     * Constructs an instance of the base class `Currency`.
+     * @param decimals decimals of the currency
+     * @param symbol symbol of the currency
+     * @param name of the currency
+     * @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
+     */
+    constructor(decimals: number, symbol: string, name: string, logoUrl?: string, isNative?: boolean, isToken?: boolean, coinGeckoId?: string);
+    /**
+     * Returns whether this currency is functionally equivalent to the other currency
+     * @param other the other currency
+     */
+    equals(other: Currency): boolean;
+    /**
+     * Returns the asset representation of this currency
+     */
+    asset(): Asset;
+    static toCurrency(currency?: any): Currency;
+}

package/dist/esm/entities/financial/currency.js

@@ -0,0 +1,49 @@
+import invariant from "tiny-invariant";
+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
+ */
+export class Currency extends Asset {
+    /**
+     * Constructs an instance of the base class `Currency`.
+     * @param decimals decimals of the currency
+     * @param symbol symbol of the currency
+     * @param name of the currency
+     * @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
+     */
+    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 ?? false;
+        this.isToken = isToken ?? true;
+        this.logoUrl = logoUrl;
+    }
+    /**
+     * Returns whether this currency is functionally equivalent to the other currency
+     * @param other the other currency
+     */
+    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
+     */
+    asset() {
+        return this;
+    }
+    static toCurrency(currency) {
+        if (!currency) {
+            return undefined;
+        }
+        const { asset, decimals, logoUrl, isNative } = currency;
+        return new Currency(decimals, asset.symbol, asset.name, logoUrl, isNative);
+    }
+}

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

@@ -0,0 +1,34 @@
+import JSBI from "jsbi";
+import { Fraction, BigintIsh, Rounding } from "@uniswap/sdk-core";
+import { Currency } from "./currency.js";
+export declare class CurrencyAmount extends Fraction {
+    readonly currency: Currency;
+    readonly decimalScale: JSBI;
+    private amountInFiatCurrency?;
+    /**
+     * 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: Currency, rawAmount: BigintIsh | bigint): CurrencyAmount;
+    static toCurrencyAmount(amount?: any): CurrencyAmount;
+    /**
+     * 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: Currency, numerator: BigintIsh, denominator: BigintIsh): CurrencyAmount;
+    protected constructor(currency: Currency, numerator: BigintIsh | bigint, denominator?: BigintIsh | bigint);
+    add(other: CurrencyAmount): CurrencyAmount;
+    subtract(other: CurrencyAmount): CurrencyAmount;
+    multiply(other: Fraction | BigintIsh): CurrencyAmount;
+    divide(other: Fraction | BigintIsh): CurrencyAmount;
+    cloneWithAmount(amount: bigint): CurrencyAmount;
+    toRawAmount(): bigint;
+    toCurrencyValue(price: CurrencyAmount): CurrencyAmount;
+    fiatValue(): CurrencyAmount;
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+    toExact(format?: object): string;
+}

package/dist/esm/entities/financial/currency_amount.js

@@ -0,0 +1,92 @@
+import invariant from "tiny-invariant";
+import JSBI from "jsbi";
+import { Fraction, MaxUint256, Rounding } from "@uniswap/sdk-core";
+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.
+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
+     */
+    static fromRawAmount(currency, rawAmount) {
+        return new CurrencyAmount(currency, rawAmount);
+    }
+    static toCurrencyAmount(amount) {
+        if (!amount) {
+            return undefined;
+        }
+        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
+     */
+    static fromFractionalAmount(currency, numerator, denominator) {
+        return new CurrencyAmount(currency, numerator, denominator);
+    }
+    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");
+        const added = super.add(other);
+        return CurrencyAmount.fromFractionalAmount(this.currency, added.numerator, added.denominator);
+    }
+    subtract(other) {
+        invariant(this.currency.equals(other.currency), "CURRENCY");
+        const subtracted = super.subtract(other);
+        return CurrencyAmount.fromFractionalAmount(this.currency, subtracted.numerator, subtracted.denominator);
+    }
+    multiply(other) {
+        const multiplied = super.multiply(other);
+        return CurrencyAmount.fromFractionalAmount(this.currency, multiplied.numerator, multiplied.denominator);
+    }
+    divide(other) {
+        const divided = super.divide(other);
+        return CurrencyAmount.fromFractionalAmount(this.currency, divided.numerator, divided.denominator);
+    }
+    cloneWithAmount(amount) {
+        return CurrencyAmount.fromRawAmount(this.currency, amount);
+    }
+    toRawAmount() {
+        return BigInt(this.quotient.toString());
+    }
+    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;
+    }
+    fiatValue() {
+        return this.amountInFiatCurrency;
+    }
+    toSignificant(significantDigits = 6, format, rounding = Rounding.ROUND_DOWN) {
+        return super
+            .divide(this.decimalScale)
+            .toSignificant(significantDigits, format, rounding);
+    }
+    toFixed(decimalPlaces = this.currency.decimals, format, rounding = Rounding.ROUND_DOWN) {
+        invariant(decimalPlaces <= this.currency.decimals, "DECIMALS");
+        return super
+            .divide(this.decimalScale)
+            .toFixed(decimalPlaces, format, rounding);
+    }
+    toExact(format = { groupSeparator: "" }) {
+        Big.DP = this.currency.decimals;
+        return new Big(this.quotient.toString())
+            .div(this.decimalScale.toString())
+            .toFormat(format);
+    }
+}

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

@@ -0,0 +1,41 @@
+import { Currency } from "./currency.js";
+import { TokenType } from "../../enums.js";
+/**
+ * Represents an ERC20 token with a unique address and some metadata.
+ */
+export declare class FungibleToken extends Currency {
+    readonly isToken: true;
+    /**
+     * The contract address on the chain on which this token lives
+     */
+    readonly address: string;
+    /**
+     * The chain ID on which this token resides
+     */
+    readonly chainId: bigint;
+    /**
+     * @param isNative If true, it means that this token is the native token of the chain
+     */
+    readonly isNative: boolean;
+    static toFungibleToken(token?: any): FungibleToken;
+    /**
+     * @param chainId The chain ID on which this token resides
+     * @param address The contract address on the chain on which this token lives
+     * @param decimals {@link Currency#decimals}
+     * @param symbol {@link Currency#symbol}
+     * @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, logoUrl?: string);
+    /**
+     * 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): boolean;
+    /**
+     * Returns the currency object that this token represents
+     */
+    currency(): Currency;
+    type(): TokenType;
+    identifier(): string;
+}

package/dist/esm/entities/financial/fungible_token.js

@@ -0,0 +1,64 @@
+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.
+ */
+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
+     * @param decimals {@link Currency#decimals}
+     * @param symbol {@link Currency#symbol}
+     * @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, logoUrl) {
+        // TODO(felix): add this back
+        // invariant(!_.isUndefined(getBlockchainFromBlockchainId(chainId)), "CHAIN_ID");
+        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 = checkValidAddress(address)?.toLowerCase();
+        }
+        else if (!isNative) {
+            this.address = validateAndParseAddress(address)?.toLowerCase();
+        }
+        else {
+            this.address = address;
+        }
+        this.isNative = isNative || false;
+        this.chainId = chainId;
+    }
+    /**
+     * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
+     * @param other other token to compare
+     */
+    equals(other) {
+        if (this === other)
+            return true;
+        return (this.chainId == other?.chainId &&
+            this.address.toLowerCase() == other?.address?.toLowerCase());
+    }
+    /**
+     * Returns the currency object that this token represents
+     */
+    currency() {
+        return this;
+    }
+    type() {
+        return TokenType.FUNGIBLE_TOKEN;
+    }
+    identifier() {
+        return `${this.chainId}+${this.address.toLowerCase()}`;
+    }
+}

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

@@ -0,0 +1,36 @@
+import JSBI from "jsbi";
+import { Fraction, BigintIsh, Rounding } from "@uniswap/sdk-core";
+import { FungibleToken } from "./fungible_token.js";
+import { CurrencyAmount } from "./currency_amount.js";
+export declare class FungibleTokenAmount extends Fraction {
+    readonly token: FungibleToken;
+    readonly decimalScale: JSBI;
+    private amountInFiatCurrency?;
+    /**
+     * 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: FungibleToken, rawAmount: BigintIsh | bigint, amountInFiatCurrency?: CurrencyAmount): FungibleTokenAmount;
+    /**
+     * 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: FungibleToken, numerator: BigintIsh, denominator: BigintIsh, amountInFiatCurrency?: CurrencyAmount): FungibleTokenAmount;
+    static toFungibleTokenAmount(amount?: any): FungibleTokenAmount;
+    protected constructor(fungibleToken: FungibleToken, numerator: BigintIsh | bigint, denominator?: BigintIsh | bigint, amountInFiatCurrency?: CurrencyAmount);
+    equals(other: FungibleTokenAmount): boolean;
+    add(other: FungibleTokenAmount): FungibleTokenAmount;
+    subtract(other: FungibleTokenAmount): FungibleTokenAmount;
+    multiply(other: Fraction | BigintIsh): FungibleTokenAmount;
+    divide(other: Fraction | BigintIsh): FungibleTokenAmount;
+    greaterThanOrEqual(other: FungibleTokenAmount): boolean;
+    toRawAmount(): bigint;
+    fiatValue(): CurrencyAmount;
+    toCurrencyValue(price: CurrencyAmount): CurrencyAmount;
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+    toExact(format?: object): string;
+}

package/dist/esm/entities/financial/fungible_token_amount.js

@@ -0,0 +1,95 @@
+import invariant from "tiny-invariant";
+import JSBI from "jsbi";
+import { Fraction, Rounding, MaxUint256 } from "@uniswap/sdk-core";
+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.
+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
+     */
+    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
+     */
+    static fromFractionalAmount(fungibleToken, numerator, denominator, amountInFiatCurrency) {
+        return new FungibleTokenAmount(fungibleToken, numerator, denominator, amountInFiatCurrency);
+    }
+    static toFungibleTokenAmount(amount) {
+        if (!amount) {
+            return undefined;
+        }
+        const amountInFiatCurrency = CurrencyAmount.toCurrencyAmount(amount.amountInFiatCurrency);
+        return FungibleTokenAmount.fromRawAmount(FungibleToken.toFungibleToken(amount.token), amount.value, amountInFiatCurrency);
+    }
+    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());
+    }
+    add(other) {
+        invariant(this.token.equals(other.token), "FUNGIBLE_TOKEN");
+        const added = super.add(other);
+        return FungibleTokenAmount.fromFractionalAmount(this.token, added.numerator, added.denominator);
+    }
+    subtract(other) {
+        invariant(this.token.equals(other.token), "FUNGIBLE_TOKEN");
+        const subtracted = super.subtract(other);
+        return FungibleTokenAmount.fromFractionalAmount(this.token, subtracted.numerator, subtracted.denominator);
+    }
+    multiply(other) {
+        const multiplied = super.multiply(other);
+        return FungibleTokenAmount.fromFractionalAmount(this.token, multiplied.numerator, multiplied.denominator);
+    }
+    divide(other) {
+        const divided = super.divide(other);
+        return FungibleTokenAmount.fromFractionalAmount(this.token, divided.numerator, divided.denominator);
+    }
+    greaterThanOrEqual(other) {
+        return this.greaterThan(other) || this.equals(other);
+    }
+    toRawAmount() {
+        return BigInt(this.quotient.toString());
+    }
+    fiatValue() {
+        return this.amountInFiatCurrency;
+    }
+    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;
+    }
+    toSignificant(significantDigits = 6, format, rounding = Rounding.ROUND_DOWN) {
+        return super
+            .divide(this.decimalScale)
+            .toSignificant(significantDigits, format, rounding);
+    }
+    toFixed(decimalPlaces = this.token.decimals, format, rounding = Rounding.ROUND_DOWN) {
+        invariant(decimalPlaces <= this.token.decimals, "DECIMALS");
+        return super
+            .divide(this.decimalScale)
+            .toFixed(decimalPlaces, format, rounding);
+    }
+    toExact(format = { groupSeparator: "" }) {
+        Big.DP = this.token.decimals;
+        return new Big(this.quotient.toString())
+            .div(this.decimalScale.toString())
+            .toFormat(format);
+    }
+}

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

@@ -0,0 +1,39 @@
+import { Asset } from "./asset.js";
+import { TokenType } from "../../enums.js";
+/**
+ * Represents an ERC721 token with a unique address and some metadata.
+ */
+export declare class NonFungibleToken extends Asset {
+    readonly isNative: false;
+    readonly isToken: true;
+    /**
+     * The contract address on the chain on which this token lives
+     */
+    readonly address: string;
+    /**
+     * The chain ID on which this token resides
+     */
+    readonly chainId: bigint;
+    readonly url?: string;
+    /**
+     * @param chainId The chain ID on which this token resides
+     * @param address The contract address on the chain on which this token lives
+     * @param symbol {@link Currency#symbol}
+     * @param name {@link Currency#name}
+     * @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: bigint, address: string, symbol: string, name: string, url?: string, bypassChecksum?: boolean, coinGeckoId?: string);
+    static toNonFungibleToken(nft?: any): NonFungibleToken;
+    /**
+     * 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): boolean;
+    /**
+     * Returns the asset representation of this currency
+     */
+    asset(): Asset;
+    type(): TokenType;
+    identifier(): string;
+}