lampamazaza-new-internal-utils 0.24.3

package/dist/utils/tokenUtils.cjs

@@ -0,0 +1,263 @@
+const require_assert = require('./assert.cjs');
+const require_near = require('./near.cjs');
+const require_token = require('./token.cjs');
+
+//#region src/utils/tokenUtils.ts
+function computeTotalBalance(token, balances) {
+	if (Array.isArray(token)) {
+		const uniqueTokens = new Set(token);
+		let total = 0n;
+		for (const tokenId of uniqueTokens) {
+			const balance = balances[tokenId];
+			if (balance == null) return;
+			total += balance;
+		}
+		return total;
+	}
+	if (require_token.isBaseToken(token)) return balances[token.defuseAssetId];
+	return computeTotalBalance(token.groupedTokens.map((t) => t.defuseAssetId), balances);
+}
+var DuplicateTokenError = class extends Error {
+	constructor(tokenId, decimals1, decimals2) {
+		super(`Duplicate token ${tokenId} found with different decimals: ${decimals1} and ${decimals2}`);
+		this.name = "DuplicateTokenError";
+	}
+};
+function adjustDecimals(amount, fromDecimals, toDecimals) {
+	if (fromDecimals === toDecimals) return amount;
+	if (fromDecimals > toDecimals) return amount / BigInt(10 ** (fromDecimals - toDecimals));
+	return amount * BigInt(10 ** (toDecimals - fromDecimals));
+}
+function deduplicateTokens(tokens) {
+	const tokenMap = /* @__PURE__ */ new Map();
+	for (const token of tokens) {
+		const existing = tokenMap.get(token.defuseAssetId);
+		if (existing) {
+			if (existing.decimals !== token.decimals) throw new DuplicateTokenError(token.defuseAssetId, existing.decimals, token.decimals);
+			continue;
+		}
+		tokenMap.set(token.defuseAssetId, token);
+	}
+	return Array.from(tokenMap.values());
+}
+/**
+* @param token - The token or array of tokens to compute the balance for.
+* @param balances - The mapping of token balances.
+* @param config - Configuration options.
+* @param config.strict - Ensures all tokens have a balance if `true`, otherwise returns `undefined`.
+*/
+function computeTotalBalanceDifferentDecimals(token, balances, config = { strict: true }) {
+	if (!Array.isArray(token) && require_token.isBaseToken(token)) token = [token];
+	const uniqueTokens = deduplicateTokens(Array.isArray(token) ? token : token.groupedTokens);
+	if (uniqueTokens.length === 0) return {
+		amount: 0n,
+		decimals: 0
+	};
+	const maxDecimals = Math.max(...uniqueTokens.map((t) => t.decimals));
+	let total = null;
+	for (const t of uniqueTokens) {
+		const balance = balances[t.defuseAssetId];
+		if (balance == null) {
+			if (config.strict) return;
+			continue;
+		}
+		total ??= 0n;
+		total += adjustDecimals(balance, t.decimals, maxDecimals);
+	}
+	if (total == null) return;
+	return {
+		amount: total,
+		decimals: maxDecimals
+	};
+}
+function computeTotalDeltaDifferentDecimals(tokens, tokenDeltas) {
+	const mapping = {};
+	for (const [token, amount] of tokenDeltas) {
+		mapping[token] ??= 0n;
+		mapping[token] += amount;
+	}
+	return computeTotalBalanceDifferentDecimals(tokens, mapping, { strict: false }) ?? {
+		amount: 0n,
+		decimals: 0
+	};
+}
+/**
+* Convert a unified token to a base token, by getting the first token in the group.
+* It should be used when you need to get *ANY* single token from a unified token.
+*/
+function getAnyBaseTokenInfo(token) {
+	const t = getUnderlyingBaseTokenInfos(token)[0];
+	require_assert.assert(t != null, "Token is undefined");
+	return t;
+}
+function getUnderlyingBaseTokenInfos(token) {
+	let tokens;
+	if (Array.isArray(token)) tokens = token;
+	else tokens = require_token.isBaseToken(token) ? [token] : token.groupedTokens;
+	return deduplicateTokens(tokens);
+}
+function getDerivedToken(tokenIn, chainName) {
+	if (require_token.isBaseToken(tokenIn)) return chainName === tokenIn.chainName ? tokenIn : null;
+	if (chainName != null) {
+		const tokenOut = tokenIn.groupedTokens.find((token) => token.chainName === chainName);
+		if (tokenOut != null) return tokenOut;
+	}
+	return null;
+}
+function getTokenMaxDecimals(token) {
+	const tokens = getUnderlyingBaseTokenInfos(token);
+	return Math.max(...tokens.map((t) => t.decimals));
+}
+function compareAmounts(value1, value2) {
+	const maxDecimals = Math.max(value1.decimals, value2.decimals);
+	const normalizedAmount1 = adjustDecimals(value1.amount, value1.decimals, maxDecimals);
+	const normalizedAmount2 = adjustDecimals(value2.amount, value2.decimals, maxDecimals);
+	if (normalizedAmount1 < normalizedAmount2) return -1;
+	if (normalizedAmount1 > normalizedAmount2) return 1;
+	return 0;
+}
+function minAmounts(value1, value2) {
+	return compareAmounts(value1, value2) <= 0 ? value1 : value2;
+}
+function addAmounts(...values) {
+	const maxDecimals = Math.max(...values.map((v) => v.decimals));
+	let sum = 0n;
+	for (const v of values) sum += adjustDecimals(v.amount, v.decimals, maxDecimals);
+	return {
+		amount: sum,
+		decimals: maxDecimals
+	};
+}
+function subtractAmounts(value1, token2) {
+	return addAmounts(value1, {
+		amount: -token2.amount,
+		decimals: token2.decimals
+	});
+}
+function adjustDecimalsTokenValue(value, toDecimals) {
+	return {
+		amount: adjustDecimals(value.amount, value.decimals, toDecimals),
+		decimals: toDecimals
+	};
+}
+function truncateTokenValue(value, decimals) {
+	return adjustDecimalsTokenValue(adjustDecimalsTokenValue(value, decimals), value.decimals);
+}
+function negateTokenValue(value) {
+	return {
+		amount: -value.amount,
+		decimals: value.decimals
+	};
+}
+/**
+* 1 bip = 0.0001% = 0.000001
+* 3000 bips = 0.3% = 0.003
+* 1000000 bips = 100% = 1
+*/
+const BASIS_POINTS_DENOMINATOR = 1000000n;
+/**
+* Calculates net amount by deducting fee from gross amount.
+* @example
+* // If gross amount is 100000n with 0.3% fee, net amount is 99700n
+* netDownAmount(100000n, 3000) == 99700n
+*/
+function netDownAmount(amount, feeBip) {
+	if (feeBip < 0 || feeBip > Number(BASIS_POINTS_DENOMINATOR)) throw new Error(`Invalid feeBip value. It must be between 0 and ${BASIS_POINTS_DENOMINATOR}.`);
+	if (amount < 0n) throw new Error("Amount must be non-negative.");
+	if (amount === 0n || feeBip === 0) return amount;
+	return amount - (amount * BigInt(feeBip) + (BASIS_POINTS_DENOMINATOR - 1n)) / BASIS_POINTS_DENOMINATOR;
+}
+/**
+* Calculates gross amount needed to achieve desired net amount after fee.
+* @example
+* // To receive net 100000n after 0.3% fee, gross amount needed is 100300n
+* grossUpAmount(100000n, 3000) == 100300n
+*/
+function grossUpAmount(amount, feeBip) {
+	if (feeBip < 0 || feeBip > Number(BASIS_POINTS_DENOMINATOR)) throw new Error(`Invalid feeBip value. It must be between 0 and ${BASIS_POINTS_DENOMINATOR}.`);
+	if (amount < 0n) throw new Error("Amount must be non-negative.");
+	if (amount === 0n || feeBip === 0) return amount;
+	const feeMultiplier = BASIS_POINTS_DENOMINATOR - BigInt(feeBip);
+	return (amount * BASIS_POINTS_DENOMINATOR + (feeMultiplier - 1n)) / feeMultiplier;
+}
+/**
+* Slippage can affect only positive numbers, because positive delta mean
+* that much will receive, and user can receive a bit less than that
+* depending on market conditions.
+*/
+function accountSlippageExactIn(delta, slippageBasisPoints) {
+	return delta.map(([token, amount]) => {
+		if (amount > 0n) return [token, netDownAmount(amount, slippageBasisPoints)];
+		return [token, amount];
+	});
+}
+function filterOutPoaBridgeTokens(token) {
+	if (require_token.isBaseToken(token)) return token.bridge === "poa" ? [token] : [];
+	return token.groupedTokens.filter((t) => t.bridge === "poa");
+}
+function getTokenAccountIds(tokens) {
+	return tokens.map((t) => getTokenAccountId(t.defuseAssetId));
+}
+/**
+* Converts Defuse asset ID to token contract ID.
+* nep141:wrap.near → wrap.near
+* nep245:v2_1.omni.hot.tg:56_11111111111111111111 → v2_1.omni.hot.tg
+*/
+function getTokenAccountId(assetId) {
+	const { contractId } = parseDefuseAssetId(assetId);
+	return contractId;
+}
+/**
+* Parses Defuse asset ID into its components based on the token standard.
+* nep141:wrap.near → { standard: nep141, contractId: wrap.near }
+* nep245:v2_1.omni.hot.tg:56_11111111111111111111 -> { standard: nep245, contractId: v2_1.omni.hot.tg, tokenId: 56_11111111111111111111 }
+*/
+function parseDefuseAssetId(assetId) {
+	const [tokenStandard, tokenContractId, multiTokenId] = assetId.split(":");
+	require_assert.assert(tokenContractId != null && require_near.validateNearAddress(tokenContractId), "Incorrect format of assetId");
+	switch (tokenStandard) {
+		case "nep141": return {
+			standard: "nep141",
+			contractId: tokenContractId
+		};
+		case "nep245":
+			require_assert.assert(multiTokenId != null, "Incorrect NEP-245 token format");
+			return {
+				standard: "nep245",
+				contractId: tokenContractId,
+				tokenId: multiTokenId
+			};
+		default: require_assert.assert(false, `Unsupported token standard: ${tokenStandard}`);
+	}
+}
+function tokenAccountIdToDefuseAssetId(address) {
+	return `nep141:${address}`;
+}
+
+//#endregion
+exports.BASIS_POINTS_DENOMINATOR = BASIS_POINTS_DENOMINATOR;
+exports.DuplicateTokenError = DuplicateTokenError;
+exports.accountSlippageExactIn = accountSlippageExactIn;
+exports.addAmounts = addAmounts;
+exports.adjustDecimals = adjustDecimals;
+exports.adjustDecimalsTokenValue = adjustDecimalsTokenValue;
+exports.compareAmounts = compareAmounts;
+exports.computeTotalBalance = computeTotalBalance;
+exports.computeTotalBalanceDifferentDecimals = computeTotalBalanceDifferentDecimals;
+exports.computeTotalDeltaDifferentDecimals = computeTotalDeltaDifferentDecimals;
+exports.deduplicateTokens = deduplicateTokens;
+exports.filterOutPoaBridgeTokens = filterOutPoaBridgeTokens;
+exports.getAnyBaseTokenInfo = getAnyBaseTokenInfo;
+exports.getDerivedToken = getDerivedToken;
+exports.getTokenAccountId = getTokenAccountId;
+exports.getTokenAccountIds = getTokenAccountIds;
+exports.getTokenMaxDecimals = getTokenMaxDecimals;
+exports.getUnderlyingBaseTokenInfos = getUnderlyingBaseTokenInfos;
+exports.grossUpAmount = grossUpAmount;
+exports.minAmounts = minAmounts;
+exports.negateTokenValue = negateTokenValue;
+exports.netDownAmount = netDownAmount;
+exports.parseDefuseAssetId = parseDefuseAssetId;
+exports.subtractAmounts = subtractAmounts;
+exports.tokenAccountIdToDefuseAssetId = tokenAccountIdToDefuseAssetId;
+exports.truncateTokenValue = truncateTokenValue;

package/dist/utils/tokenUtils.d.cts

@@ -0,0 +1,88 @@
+import { BaseTokenInfo, TokenValue, UnifiedTokenInfo } from "../types/base.cjs";
+import { AssertErrorType } from "./assert.cjs";
+
+//#region src/utils/tokenUtils.d.ts
+type BalanceMapping = Record<string, bigint>;
+declare function computeTotalBalance(token: BaseTokenInfo["defuseAssetId"][] | BaseTokenInfo | UnifiedTokenInfo, balances: BalanceMapping): bigint | undefined;
+declare class DuplicateTokenError extends Error {
+  constructor(tokenId: string, decimals1: number, decimals2: number);
+}
+declare function adjustDecimals(amount: bigint, fromDecimals: number, toDecimals: number): bigint;
+declare function deduplicateTokens(tokens: BaseTokenInfo[]): BaseTokenInfo[];
+/**
+ * @param token - The token or array of tokens to compute the balance for.
+ * @param balances - The mapping of token balances.
+ * @param config - Configuration options.
+ * @param config.strict - Ensures all tokens have a balance if `true`, otherwise returns `undefined`.
+ */
+declare function computeTotalBalanceDifferentDecimals(token: BaseTokenInfo[] | BaseTokenInfo | UnifiedTokenInfo, balances: BalanceMapping, config?: {
+  strict: boolean;
+}): TokenValue | undefined;
+declare function computeTotalDeltaDifferentDecimals(tokens: BaseTokenInfo[], tokenDeltas: [string, bigint][]): TokenValue;
+/**
+ * Convert a unified token to a base token, by getting the first token in the group.
+ * It should be used when you need to get *ANY* single token from a unified token.
+ */
+declare function getAnyBaseTokenInfo(token: BaseTokenInfo | UnifiedTokenInfo): BaseTokenInfo;
+declare function getUnderlyingBaseTokenInfos(token: BaseTokenInfo | UnifiedTokenInfo | BaseTokenInfo[]): BaseTokenInfo[];
+declare function getDerivedToken(tokenIn: BaseTokenInfo | UnifiedTokenInfo, chainName: string | null): BaseTokenInfo | null;
+declare function getTokenMaxDecimals(token: BaseTokenInfo | UnifiedTokenInfo): number;
+declare function compareAmounts(value1: TokenValue, value2: TokenValue): -1 | 0 | 1;
+declare function minAmounts(value1: TokenValue, value2: TokenValue): TokenValue;
+declare function addAmounts(...values: [TokenValue, TokenValue, ...TokenValue[]]): TokenValue;
+declare function subtractAmounts(value1: TokenValue, token2: TokenValue): TokenValue;
+declare function adjustDecimalsTokenValue(value: TokenValue, toDecimals: number): TokenValue;
+declare function truncateTokenValue(value: TokenValue, decimals: number): TokenValue;
+declare function negateTokenValue(value: TokenValue): TokenValue;
+/**
+ * 1 bip = 0.0001% = 0.000001
+ * 3000 bips = 0.3% = 0.003
+ * 1000000 bips = 100% = 1
+ */
+declare const BASIS_POINTS_DENOMINATOR = 1000000n;
+/**
+ * Calculates net amount by deducting fee from gross amount.
+ * @example
+ * // If gross amount is 100000n with 0.3% fee, net amount is 99700n
+ * netDownAmount(100000n, 3000) == 99700n
+ */
+declare function netDownAmount(amount: bigint, feeBip: number): bigint;
+/**
+ * Calculates gross amount needed to achieve desired net amount after fee.
+ * @example
+ * // To receive net 100000n after 0.3% fee, gross amount needed is 100300n
+ * grossUpAmount(100000n, 3000) == 100300n
+ */
+declare function grossUpAmount(amount: bigint, feeBip: number): bigint;
+/**
+ * Slippage can affect only positive numbers, because positive delta mean
+ * that much will receive, and user can receive a bit less than that
+ * depending on market conditions.
+ */
+declare function accountSlippageExactIn(delta: [string, bigint][], slippageBasisPoints: number): [string, bigint][];
+declare function filterOutPoaBridgeTokens(token: BaseTokenInfo | UnifiedTokenInfo): BaseTokenInfo[];
+declare function getTokenAccountIds(tokens: BaseTokenInfo[]): string[];
+/**
+ * Converts Defuse asset ID to token contract ID.
+ * nep141:wrap.near → wrap.near
+ * nep245:v2_1.omni.hot.tg:56_11111111111111111111 → v2_1.omni.hot.tg
+ */
+declare function getTokenAccountId(assetId: string): string;
+type ParseDefuseAssetIdReturnType = {
+  standard: "nep141";
+  contractId: string;
+} | {
+  standard: "nep245";
+  contractId: string;
+  tokenId: string;
+};
+type ParseDefuseAssetIdErrorType = AssertErrorType;
+/**
+ * Parses Defuse asset ID into its components based on the token standard.
+ * nep141:wrap.near → { standard: nep141, contractId: wrap.near }
+ * nep245:v2_1.omni.hot.tg:56_11111111111111111111 -> { standard: nep245, contractId: v2_1.omni.hot.tg, tokenId: 56_11111111111111111111 }
+ */
+declare function parseDefuseAssetId(assetId: string): ParseDefuseAssetIdReturnType;
+declare function tokenAccountIdToDefuseAssetId(address: string): string;
+//#endregion
+export { BASIS_POINTS_DENOMINATOR, DuplicateTokenError, ParseDefuseAssetIdErrorType, ParseDefuseAssetIdReturnType, accountSlippageExactIn, addAmounts, adjustDecimals, adjustDecimalsTokenValue, compareAmounts, computeTotalBalance, computeTotalBalanceDifferentDecimals, computeTotalDeltaDifferentDecimals, deduplicateTokens, filterOutPoaBridgeTokens, getAnyBaseTokenInfo, getDerivedToken, getTokenAccountId, getTokenAccountIds, getTokenMaxDecimals, getUnderlyingBaseTokenInfos, grossUpAmount, minAmounts, negateTokenValue, netDownAmount, parseDefuseAssetId, subtractAmounts, tokenAccountIdToDefuseAssetId, truncateTokenValue };

package/dist/utils/tokenUtils.d.ts

@@ -0,0 +1,88 @@
+import { BaseTokenInfo, TokenValue, UnifiedTokenInfo } from "../types/base.js";
+import { AssertErrorType } from "./assert.js";
+
+//#region src/utils/tokenUtils.d.ts
+type BalanceMapping = Record<string, bigint>;
+declare function computeTotalBalance(token: BaseTokenInfo["defuseAssetId"][] | BaseTokenInfo | UnifiedTokenInfo, balances: BalanceMapping): bigint | undefined;
+declare class DuplicateTokenError extends Error {
+  constructor(tokenId: string, decimals1: number, decimals2: number);
+}
+declare function adjustDecimals(amount: bigint, fromDecimals: number, toDecimals: number): bigint;
+declare function deduplicateTokens(tokens: BaseTokenInfo[]): BaseTokenInfo[];
+/**
+ * @param token - The token or array of tokens to compute the balance for.
+ * @param balances - The mapping of token balances.
+ * @param config - Configuration options.
+ * @param config.strict - Ensures all tokens have a balance if `true`, otherwise returns `undefined`.
+ */
+declare function computeTotalBalanceDifferentDecimals(token: BaseTokenInfo[] | BaseTokenInfo | UnifiedTokenInfo, balances: BalanceMapping, config?: {
+  strict: boolean;
+}): TokenValue | undefined;
+declare function computeTotalDeltaDifferentDecimals(tokens: BaseTokenInfo[], tokenDeltas: [string, bigint][]): TokenValue;
+/**
+ * Convert a unified token to a base token, by getting the first token in the group.
+ * It should be used when you need to get *ANY* single token from a unified token.
+ */
+declare function getAnyBaseTokenInfo(token: BaseTokenInfo | UnifiedTokenInfo): BaseTokenInfo;
+declare function getUnderlyingBaseTokenInfos(token: BaseTokenInfo | UnifiedTokenInfo | BaseTokenInfo[]): BaseTokenInfo[];
+declare function getDerivedToken(tokenIn: BaseTokenInfo | UnifiedTokenInfo, chainName: string | null): BaseTokenInfo | null;
+declare function getTokenMaxDecimals(token: BaseTokenInfo | UnifiedTokenInfo): number;
+declare function compareAmounts(value1: TokenValue, value2: TokenValue): -1 | 0 | 1;
+declare function minAmounts(value1: TokenValue, value2: TokenValue): TokenValue;
+declare function addAmounts(...values: [TokenValue, TokenValue, ...TokenValue[]]): TokenValue;
+declare function subtractAmounts(value1: TokenValue, token2: TokenValue): TokenValue;
+declare function adjustDecimalsTokenValue(value: TokenValue, toDecimals: number): TokenValue;
+declare function truncateTokenValue(value: TokenValue, decimals: number): TokenValue;
+declare function negateTokenValue(value: TokenValue): TokenValue;
+/**
+ * 1 bip = 0.0001% = 0.000001
+ * 3000 bips = 0.3% = 0.003
+ * 1000000 bips = 100% = 1
+ */
+declare const BASIS_POINTS_DENOMINATOR = 1000000n;
+/**
+ * Calculates net amount by deducting fee from gross amount.
+ * @example
+ * // If gross amount is 100000n with 0.3% fee, net amount is 99700n
+ * netDownAmount(100000n, 3000) == 99700n
+ */
+declare function netDownAmount(amount: bigint, feeBip: number): bigint;
+/**
+ * Calculates gross amount needed to achieve desired net amount after fee.
+ * @example
+ * // To receive net 100000n after 0.3% fee, gross amount needed is 100300n
+ * grossUpAmount(100000n, 3000) == 100300n
+ */
+declare function grossUpAmount(amount: bigint, feeBip: number): bigint;
+/**
+ * Slippage can affect only positive numbers, because positive delta mean
+ * that much will receive, and user can receive a bit less than that
+ * depending on market conditions.
+ */
+declare function accountSlippageExactIn(delta: [string, bigint][], slippageBasisPoints: number): [string, bigint][];
+declare function filterOutPoaBridgeTokens(token: BaseTokenInfo | UnifiedTokenInfo): BaseTokenInfo[];
+declare function getTokenAccountIds(tokens: BaseTokenInfo[]): string[];
+/**
+ * Converts Defuse asset ID to token contract ID.
+ * nep141:wrap.near → wrap.near
+ * nep245:v2_1.omni.hot.tg:56_11111111111111111111 → v2_1.omni.hot.tg
+ */
+declare function getTokenAccountId(assetId: string): string;
+type ParseDefuseAssetIdReturnType = {
+  standard: "nep141";
+  contractId: string;
+} | {
+  standard: "nep245";
+  contractId: string;
+  tokenId: string;
+};
+type ParseDefuseAssetIdErrorType = AssertErrorType;
+/**
+ * Parses Defuse asset ID into its components based on the token standard.
+ * nep141:wrap.near → { standard: nep141, contractId: wrap.near }
+ * nep245:v2_1.omni.hot.tg:56_11111111111111111111 -> { standard: nep245, contractId: v2_1.omni.hot.tg, tokenId: 56_11111111111111111111 }
+ */
+declare function parseDefuseAssetId(assetId: string): ParseDefuseAssetIdReturnType;
+declare function tokenAccountIdToDefuseAssetId(address: string): string;
+//#endregion
+export { BASIS_POINTS_DENOMINATOR, DuplicateTokenError, ParseDefuseAssetIdErrorType, ParseDefuseAssetIdReturnType, accountSlippageExactIn, addAmounts, adjustDecimals, adjustDecimalsTokenValue, compareAmounts, computeTotalBalance, computeTotalBalanceDifferentDecimals, computeTotalDeltaDifferentDecimals, deduplicateTokens, filterOutPoaBridgeTokens, getAnyBaseTokenInfo, getDerivedToken, getTokenAccountId, getTokenAccountIds, getTokenMaxDecimals, getUnderlyingBaseTokenInfos, grossUpAmount, minAmounts, negateTokenValue, netDownAmount, parseDefuseAssetId, subtractAmounts, tokenAccountIdToDefuseAssetId, truncateTokenValue };

package/dist/utils/tokenUtils.js

@@ -0,0 +1,238 @@
+import { assert } from "./assert.js";
+import { validateNearAddress } from "./near.js";
+import { isBaseToken } from "./token.js";
+
+//#region src/utils/tokenUtils.ts
+function computeTotalBalance(token, balances) {
+	if (Array.isArray(token)) {
+		const uniqueTokens = new Set(token);
+		let total = 0n;
+		for (const tokenId of uniqueTokens) {
+			const balance = balances[tokenId];
+			if (balance == null) return;
+			total += balance;
+		}
+		return total;
+	}
+	if (isBaseToken(token)) return balances[token.defuseAssetId];
+	return computeTotalBalance(token.groupedTokens.map((t) => t.defuseAssetId), balances);
+}
+var DuplicateTokenError = class extends Error {
+	constructor(tokenId, decimals1, decimals2) {
+		super(`Duplicate token ${tokenId} found with different decimals: ${decimals1} and ${decimals2}`);
+		this.name = "DuplicateTokenError";
+	}
+};
+function adjustDecimals(amount, fromDecimals, toDecimals) {
+	if (fromDecimals === toDecimals) return amount;
+	if (fromDecimals > toDecimals) return amount / BigInt(10 ** (fromDecimals - toDecimals));
+	return amount * BigInt(10 ** (toDecimals - fromDecimals));
+}
+function deduplicateTokens(tokens) {
+	const tokenMap = /* @__PURE__ */ new Map();
+	for (const token of tokens) {
+		const existing = tokenMap.get(token.defuseAssetId);
+		if (existing) {
+			if (existing.decimals !== token.decimals) throw new DuplicateTokenError(token.defuseAssetId, existing.decimals, token.decimals);
+			continue;
+		}
+		tokenMap.set(token.defuseAssetId, token);
+	}
+	return Array.from(tokenMap.values());
+}
+/**
+* @param token - The token or array of tokens to compute the balance for.
+* @param balances - The mapping of token balances.
+* @param config - Configuration options.
+* @param config.strict - Ensures all tokens have a balance if `true`, otherwise returns `undefined`.
+*/
+function computeTotalBalanceDifferentDecimals(token, balances, config = { strict: true }) {
+	if (!Array.isArray(token) && isBaseToken(token)) token = [token];
+	const uniqueTokens = deduplicateTokens(Array.isArray(token) ? token : token.groupedTokens);
+	if (uniqueTokens.length === 0) return {
+		amount: 0n,
+		decimals: 0
+	};
+	const maxDecimals = Math.max(...uniqueTokens.map((t) => t.decimals));
+	let total = null;
+	for (const t of uniqueTokens) {
+		const balance = balances[t.defuseAssetId];
+		if (balance == null) {
+			if (config.strict) return;
+			continue;
+		}
+		total ??= 0n;
+		total += adjustDecimals(balance, t.decimals, maxDecimals);
+	}
+	if (total == null) return;
+	return {
+		amount: total,
+		decimals: maxDecimals
+	};
+}
+function computeTotalDeltaDifferentDecimals(tokens, tokenDeltas) {
+	const mapping = {};
+	for (const [token, amount] of tokenDeltas) {
+		mapping[token] ??= 0n;
+		mapping[token] += amount;
+	}
+	return computeTotalBalanceDifferentDecimals(tokens, mapping, { strict: false }) ?? {
+		amount: 0n,
+		decimals: 0
+	};
+}
+/**
+* Convert a unified token to a base token, by getting the first token in the group.
+* It should be used when you need to get *ANY* single token from a unified token.
+*/
+function getAnyBaseTokenInfo(token) {
+	const t = getUnderlyingBaseTokenInfos(token)[0];
+	assert(t != null, "Token is undefined");
+	return t;
+}
+function getUnderlyingBaseTokenInfos(token) {
+	let tokens;
+	if (Array.isArray(token)) tokens = token;
+	else tokens = isBaseToken(token) ? [token] : token.groupedTokens;
+	return deduplicateTokens(tokens);
+}
+function getDerivedToken(tokenIn, chainName) {
+	if (isBaseToken(tokenIn)) return chainName === tokenIn.chainName ? tokenIn : null;
+	if (chainName != null) {
+		const tokenOut = tokenIn.groupedTokens.find((token) => token.chainName === chainName);
+		if (tokenOut != null) return tokenOut;
+	}
+	return null;
+}
+function getTokenMaxDecimals(token) {
+	const tokens = getUnderlyingBaseTokenInfos(token);
+	return Math.max(...tokens.map((t) => t.decimals));
+}
+function compareAmounts(value1, value2) {
+	const maxDecimals = Math.max(value1.decimals, value2.decimals);
+	const normalizedAmount1 = adjustDecimals(value1.amount, value1.decimals, maxDecimals);
+	const normalizedAmount2 = adjustDecimals(value2.amount, value2.decimals, maxDecimals);
+	if (normalizedAmount1 < normalizedAmount2) return -1;
+	if (normalizedAmount1 > normalizedAmount2) return 1;
+	return 0;
+}
+function minAmounts(value1, value2) {
+	return compareAmounts(value1, value2) <= 0 ? value1 : value2;
+}
+function addAmounts(...values) {
+	const maxDecimals = Math.max(...values.map((v) => v.decimals));
+	let sum = 0n;
+	for (const v of values) sum += adjustDecimals(v.amount, v.decimals, maxDecimals);
+	return {
+		amount: sum,
+		decimals: maxDecimals
+	};
+}
+function subtractAmounts(value1, token2) {
+	return addAmounts(value1, {
+		amount: -token2.amount,
+		decimals: token2.decimals
+	});
+}
+function adjustDecimalsTokenValue(value, toDecimals) {
+	return {
+		amount: adjustDecimals(value.amount, value.decimals, toDecimals),
+		decimals: toDecimals
+	};
+}
+function truncateTokenValue(value, decimals) {
+	return adjustDecimalsTokenValue(adjustDecimalsTokenValue(value, decimals), value.decimals);
+}
+function negateTokenValue(value) {
+	return {
+		amount: -value.amount,
+		decimals: value.decimals
+	};
+}
+/**
+* 1 bip = 0.0001% = 0.000001
+* 3000 bips = 0.3% = 0.003
+* 1000000 bips = 100% = 1
+*/
+const BASIS_POINTS_DENOMINATOR = 1000000n;
+/**
+* Calculates net amount by deducting fee from gross amount.
+* @example
+* // If gross amount is 100000n with 0.3% fee, net amount is 99700n
+* netDownAmount(100000n, 3000) == 99700n
+*/
+function netDownAmount(amount, feeBip) {
+	if (feeBip < 0 || feeBip > Number(BASIS_POINTS_DENOMINATOR)) throw new Error(`Invalid feeBip value. It must be between 0 and ${BASIS_POINTS_DENOMINATOR}.`);
+	if (amount < 0n) throw new Error("Amount must be non-negative.");
+	if (amount === 0n || feeBip === 0) return amount;
+	return amount - (amount * BigInt(feeBip) + (BASIS_POINTS_DENOMINATOR - 1n)) / BASIS_POINTS_DENOMINATOR;
+}
+/**
+* Calculates gross amount needed to achieve desired net amount after fee.
+* @example
+* // To receive net 100000n after 0.3% fee, gross amount needed is 100300n
+* grossUpAmount(100000n, 3000) == 100300n
+*/
+function grossUpAmount(amount, feeBip) {
+	if (feeBip < 0 || feeBip > Number(BASIS_POINTS_DENOMINATOR)) throw new Error(`Invalid feeBip value. It must be between 0 and ${BASIS_POINTS_DENOMINATOR}.`);
+	if (amount < 0n) throw new Error("Amount must be non-negative.");
+	if (amount === 0n || feeBip === 0) return amount;
+	const feeMultiplier = BASIS_POINTS_DENOMINATOR - BigInt(feeBip);
+	return (amount * BASIS_POINTS_DENOMINATOR + (feeMultiplier - 1n)) / feeMultiplier;
+}
+/**
+* Slippage can affect only positive numbers, because positive delta mean
+* that much will receive, and user can receive a bit less than that
+* depending on market conditions.
+*/
+function accountSlippageExactIn(delta, slippageBasisPoints) {
+	return delta.map(([token, amount]) => {
+		if (amount > 0n) return [token, netDownAmount(amount, slippageBasisPoints)];
+		return [token, amount];
+	});
+}
+function filterOutPoaBridgeTokens(token) {
+	if (isBaseToken(token)) return token.bridge === "poa" ? [token] : [];
+	return token.groupedTokens.filter((t) => t.bridge === "poa");
+}
+function getTokenAccountIds(tokens) {
+	return tokens.map((t) => getTokenAccountId(t.defuseAssetId));
+}
+/**
+* Converts Defuse asset ID to token contract ID.
+* nep141:wrap.near → wrap.near
+* nep245:v2_1.omni.hot.tg:56_11111111111111111111 → v2_1.omni.hot.tg
+*/
+function getTokenAccountId(assetId) {
+	const { contractId } = parseDefuseAssetId(assetId);
+	return contractId;
+}
+/**
+* Parses Defuse asset ID into its components based on the token standard.
+* nep141:wrap.near → { standard: nep141, contractId: wrap.near }
+* nep245:v2_1.omni.hot.tg:56_11111111111111111111 -> { standard: nep245, contractId: v2_1.omni.hot.tg, tokenId: 56_11111111111111111111 }
+*/
+function parseDefuseAssetId(assetId) {
+	const [tokenStandard, tokenContractId, multiTokenId] = assetId.split(":");
+	assert(tokenContractId != null && validateNearAddress(tokenContractId), "Incorrect format of assetId");
+	switch (tokenStandard) {
+		case "nep141": return {
+			standard: "nep141",
+			contractId: tokenContractId
+		};
+		case "nep245":
+			assert(multiTokenId != null, "Incorrect NEP-245 token format");
+			return {
+				standard: "nep245",
+				contractId: tokenContractId,
+				tokenId: multiTokenId
+			};
+		default: assert(false, `Unsupported token standard: ${tokenStandard}`);
+	}
+}
+function tokenAccountIdToDefuseAssetId(address) {
+	return `nep141:${address}`;
+}
+
+//#endregion
+export { BASIS_POINTS_DENOMINATOR, DuplicateTokenError, accountSlippageExactIn, addAmounts, adjustDecimals, adjustDecimalsTokenValue, compareAmounts, computeTotalBalance, computeTotalBalanceDifferentDecimals, computeTotalDeltaDifferentDecimals, deduplicateTokens, filterOutPoaBridgeTokens, getAnyBaseTokenInfo, getDerivedToken, getTokenAccountId, getTokenAccountIds, getTokenMaxDecimals, getUnderlyingBaseTokenInfos, grossUpAmount, minAmounts, negateTokenValue, netDownAmount, parseDefuseAssetId, subtractAmounts, tokenAccountIdToDefuseAssetId, truncateTokenValue };