@orb-labs/orby-core 0.0.14 → 0.0.16

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Asset = void 0;
+/**
+ * An Asset is any fungible financial instrument, including Ether, all ERC20 tokens, and NFTs
+ */
+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}`;
+    }
+}
+exports.Asset = Asset;

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

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Currency = void 0;
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+const asset_js_1 = require("./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
+ */
+class Currency extends asset_js_1.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);
+        (0, tiny_invariant_1.default)(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);
+    }
+}
+exports.Currency = Currency;

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

@@ -0,0 +1,99 @@
+"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_js_1 = require("./currency.js");
+const constants_js_1 = require("../../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.
+class CurrencyAmount extends sdk_core_1.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_js_1.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());
+        (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) {
+        if (!other) {
+            return this;
+        }
+        (0, tiny_invariant_1.default)(this.currency.equals(other.currency), "CURRENCY");
+        const added = super.add(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);
+        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_1.default.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 = sdk_core_1.Rounding.ROUND_DOWN) {
+        return super
+            .divide(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)
+            .toFixed(decimalPlaces, format, rounding);
+    }
+    toExact(format = { groupSeparator: "" }) {
+        constants_js_1.Big.DP = this.currency.decimals;
+        return new constants_js_1.Big(this.quotient.toString())
+            .div(this.decimalScale.toString())
+            .toFormat(format);
+    }
+}
+exports.CurrencyAmount = CurrencyAmount;

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FungibleToken = void 0;
+const currency_js_1 = require("./currency.js");
+const validateAndParseAddress_js_1 = require("../../utils/validateAndParseAddress.js");
+const enums_js_1 = require("../../enums.js");
+/**
+ * Represents an ERC20 token with a unique address and some metadata.
+ */
+class FungibleToken extends currency_js_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);
+    }
+    /**
+     * @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 = (0, validateAndParseAddress_js_1.checkValidAddress)(address)?.toLowerCase();
+        }
+        else if (!isNative) {
+            this.address = (0, validateAndParseAddress_js_1.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 enums_js_1.TokenType.FUNGIBLE_TOKEN;
+    }
+    identifier() {
+        return `${this.chainId}+${this.address.toLowerCase()}`;
+    }
+}
+exports.FungibleToken = FungibleToken;

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

@@ -0,0 +1,102 @@
+"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_js_1 = require("./fungible_token.js");
+const currency_amount_js_1 = require("./currency_amount.js");
+const constants_js_1 = require("../../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.
+class FungibleTokenAmount extends sdk_core_1.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 = currency_amount_js_1.CurrencyAmount.toCurrencyAmount(amount.amountInFiatCurrency);
+        return FungibleTokenAmount.fromRawAmount(fungible_token_js_1.FungibleToken.toFungibleToken(amount.token), amount.value, amountInFiatCurrency);
+    }
+    constructor(fungibleToken, numerator, denominator, amountInFiatCurrency) {
+        super(numerator.toString(), denominator?.toString());
+        (0, tiny_invariant_1.default)(jsbi_1.default.lessThanOrEqual(this.quotient, sdk_core_1.MaxUint256), "AMOUNT"); // TODO(imti): fix this
+        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) {
+        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);
+        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);
+        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_1.default.multiply(fraction.denominator, this.decimalScale);
+        this.amountInFiatCurrency = currency_amount_js_1.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)
+            .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)
+            .toFixed(decimalPlaces, format, rounding);
+    }
+    toExact(format = { groupSeparator: "" }) {
+        constants_js_1.Big.DP = this.token.decimals;
+        return new constants_js_1.Big(this.quotient.toString())
+            .div(this.decimalScale.toString())
+            .toFormat(format);
+    }
+}
+exports.FungibleTokenAmount = FungibleTokenAmount;

package/dist/cjs/entities/financial/non_fungible_token.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonFungibleToken = void 0;
+const asset_js_1 = require("./asset.js");
+const validateAndParseAddress_js_1 = require("../../utils/validateAndParseAddress.js");
+const enums_js_1 = require("../../enums.js");
+/**
+ * Represents an ERC721 token with a unique address and some metadata.
+ */
+class NonFungibleToken extends asset_js_1.Asset {
+    /**
+     * @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, address, symbol, name, url, bypassChecksum, coinGeckoId) {
+        // TODO(felix): add this back
+        // invariant(!_.isUndefined(getBlockchainFromBlockchainId(chainId)), "CHAIN_ID");
+        super(symbol, name, coinGeckoId);
+        this.isNative = false;
+        this.isToken = true;
+        if (bypassChecksum) {
+            this.address = (0, validateAndParseAddress_js_1.checkValidAddress)(address)?.toLowerCase();
+        }
+        else {
+            this.address = (0, validateAndParseAddress_js_1.validateAndParseAddress)(address)?.toLowerCase();
+        }
+        this.chainId = chainId;
+        this.url = url;
+    }
+    static toNonFungibleToken(nft) {
+        if (!nft) {
+            return undefined;
+        }
+        const asset = asset_js_1.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) {
+        // 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() {
+        return this;
+    }
+    type() {
+        return enums_js_1.TokenType.NON_FUNGIBLE_TOKEN;
+    }
+    identifier() {
+        return `${this.chainId}+${this.address.toLowerCase()}`;
+    }
+}
+exports.NonFungibleToken = NonFungibleToken;

package/dist/cjs/entities/financial/semi_fungible_token.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemiFungibleToken = void 0;
+const currency_js_1 = require("./currency.js");
+const validateAndParseAddress_js_1 = require("../../utils/validateAndParseAddress.js");
+const enums_js_1 = require("../../enums.js");
+/**
+ * Represents an ERC1155 token with a unique address and some metadata.
+ */
+class SemiFungibleToken extends currency_js_1.Currency {
+    /**
+     *
+     * @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 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, decimals, symbol, name, url, bypassChecksum, coinGeckoId) {
+        // TODO(felix): add this back
+        // invariant(!_.isUndefined(getBlockchainFromBlockchainId(chainId)), "CHAIN_ID");
+        super(decimals, symbol, name, url, false, true, coinGeckoId);
+        this.isNative = false;
+        this.isToken = true;
+        if (bypassChecksum) {
+            this.address = (0, validateAndParseAddress_js_1.checkValidAddress)(address)?.toLowerCase();
+        }
+        else {
+            this.address = (0, validateAndParseAddress_js_1.validateAndParseAddress)(address)?.toLowerCase();
+        }
+        this.chainId = chainId;
+        this.url = url;
+    }
+    static toSemiFungibleToken(sft) {
+        if (!sft) {
+            return undefined;
+        }
+        const currency = currency_js_1.Currency.toCurrency(sft.currency);
+        return new SemiFungibleToken(sft.chainId, sft.address, currency.decimals, currency.symbol, currency.name, sft.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) {
+        // short circuit on reference equality
+        if (this === other)
+            return true;
+        return (this.chainId === other.chainId &&
+            this.address === other.address.toLowerCase());
+    }
+    /**
+     * Returns the currency object that this token represents
+     */
+    currency() {
+        return this;
+    }
+    type() {
+        return enums_js_1.TokenType.SEMI_FUNGIBLE_TOKEN;
+    }
+    identifier() {
+        return `${this.chainId}+${this.address.toLowerCase()}`;
+    }
+}
+exports.SemiFungibleToken = SemiFungibleToken;

package/dist/cjs/entities/library_request.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LibraryRequest = void 0;
+const enums_js_1 = require("../enums.js");
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+class LibraryRequest {
+    constructor(library, client, provider) {
+        if (library == enums_js_1.LIBRARY_TYPE.VIEM) {
+            (0, tiny_invariant_1.default)(client, "CLIENT");
+            (0, tiny_invariant_1.default)(!provider, "PROVIDER");
+            this.client = client;
+        }
+        else if (library == enums_js_1.LIBRARY_TYPE.ETHERS) {
+            (0, tiny_invariant_1.default)(provider, "PROVIDER");
+            (0, tiny_invariant_1.default)(!client, "CLIENT");
+            this.provider = provider;
+        }
+        else {
+            (0, tiny_invariant_1.default)(false, "LIBRARY");
+        }
+        this.library = library;
+        this.client = client;
+        this.provider = provider;
+    }
+    sendRequest(method, params) {
+        if (this.library == enums_js_1.LIBRARY_TYPE.VIEM) {
+            return this.client.request({ method, params });
+        }
+        else if (this.library == enums_js_1.LIBRARY_TYPE.ETHERS) {
+            return this.provider.send(method, params);
+        }
+    }
+}
+exports.LibraryRequest = LibraryRequest;

package/dist/cjs/entities/state.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.State = void 0;
+const fungible_token_amount_js_1 = require("./financial/fungible_token_amount.js");
+const non_fungible_token_js_1 = require("./financial/non_fungible_token.js");
+const semi_fungible_token_js_1 = require("./financial/semi_fungible_token.js");
+class State {
+    constructor(fungibleTokens, nonFungibleTokens, semiFungibleTokens) {
+        this.fungibleTokens = fungibleTokens.reduce((acc, amount) => {
+            acc.set(amount.token.identifier(), amount);
+            return acc;
+        }, new Map());
+        this.nonFungibleTokens = nonFungibleTokens.reduce((acc, token) => {
+            acc.set(token.identifier(), token);
+            return acc;
+        }, new Map());
+        this.semiFungibleTokens = semiFungibleTokens.reduce((acc, token) => {
+            acc.set(token.identifier(), token);
+            return acc;
+        }, new Map());
+    }
+    static fromFungibleTokenAmounts(fungibleTokenAmounts) {
+        return new State(fungibleTokenAmounts, [], []);
+    }
+    static fromTokenAndAmount(token, amount) {
+        if (!token || !amount) {
+            return undefined;
+        }
+        const fungibleTokenAmount = fungible_token_amount_js_1.FungibleTokenAmount.fromRawAmount(token, amount);
+        return State.fromFungibleTokenAmounts([fungibleTokenAmount]);
+    }
+    getFungibleTokens() {
+        return Array.from(this.fungibleTokens.values());
+    }
+    getNonFungibleTokens() {
+        return Array.from(this.nonFungibleTokens.values());
+    }
+    getSemiFungibleTokens() {
+        return Array.from(this.semiFungibleTokens.values());
+    }
+    addTokens(fungibleTokens) {
+        fungibleTokens.forEach((amount) => {
+            const identifier = amount.token.identifier();
+            const currentAmount = this.fungibleTokens.get(identifier);
+            if (currentAmount) {
+                this.fungibleTokens.set(identifier, currentAmount.add(amount));
+            }
+            else {
+                this.fungibleTokens.set(identifier, amount);
+            }
+        });
+        return this;
+    }
+    addState(other) {
+        other?.fungibleTokens?.forEach((amount) => {
+            const identifier = amount.token.identifier();
+            const currentAmount = this.fungibleTokens.get(identifier);
+            if (currentAmount) {
+                this.fungibleTokens.set(identifier, currentAmount.add(amount));
+            }
+            else {
+                this.fungibleTokens.set(identifier, amount);
+            }
+        });
+        return this;
+    }
+    deductState(other) {
+        other.fungibleTokens.forEach((amount) => {
+            const identifier = amount.token.identifier();
+            const currentAmount = this.fungibleTokens.get(identifier);
+            if (currentAmount?.toRawAmount() > amount?.toRawAmount()) {
+                this.fungibleTokens.set(identifier, currentAmount.subtract(amount));
+            }
+            else if (currentAmount) {
+                this.fungibleTokens.delete(identifier);
+            }
+        });
+        return this;
+    }
+    equals(other) {
+        if (!other) {
+            return false;
+        }
+        return (this.fungibleTokens.size == other.fungibleTokens.size &&
+            Array.from(this.fungibleTokens.entries()).every(([key, value]) => {
+                const otherValue = other.fungibleTokens.get(key);
+                return otherValue && value.equals(otherValue);
+            }));
+    }
+    addStates(states) {
+        states.forEach((state) => this.addState(state));
+        return this;
+    }
+    static mergeStates(states) {
+        return states.reduce((acc, state) => acc.addState(state), new State([], [], []));
+    }
+    static toState(state) {
+        if (!state)
+            return undefined;
+        const fungibleTokenAmounts = state.fungibleTokenAmounts.map((ft) => fungible_token_amount_js_1.FungibleTokenAmount.toFungibleTokenAmount(ft));
+        const nonFungibleTokenAmounts = state.nonFungibleTokenAmounts.map((nft) => non_fungible_token_js_1.NonFungibleToken.toNonFungibleToken(nft));
+        const semiFungibleTokenAmounts = state.semiFungibleTokenAmounts.map((sft) => semi_fungible_token_js_1.SemiFungibleToken.toSemiFungibleToken(sft));
+        return new State(fungibleTokenAmounts, nonFungibleTokenAmounts, semiFungibleTokenAmounts);
+    }
+}
+exports.State = State;