lampamazaza-new-intents-sdk 0.47.1

package/dist/src/bridges/omni-bridge/error.cjs

@@ -0,0 +1,54 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let lampamazaza_internal_utils = require("lampamazaza-internal-utils");
+
+//#region src/bridges/omni-bridge/error.ts
+var TokenNotFoundInDestinationChainError = class extends lampamazaza_internal_utils.BaseError {
+	constructor(token, destinationChain) {
+		super(`The token ${token} doesn't exist in destination chain ${destinationChain}`, {
+			metaMessages: [`Token: ${token}`, `Destination Chain: ${destinationChain}`],
+			name: "TokenNotFoundInDestinationChainError"
+		});
+		this.token = token;
+		this.destinationChain = destinationChain;
+	}
+};
+var InvalidFeeValueError = class extends lampamazaza_internal_utils.BaseError {
+	constructor(token, value) {
+		super(`Invalid fee value`, {
+			metaMessages: [`Token: ${token}`, `Fee value: ${value}`],
+			name: "InvalidFeeValueError"
+		});
+		this.token = token;
+	}
+};
+var IntentsNearOmniAvailableBalanceTooLowError = class extends lampamazaza_internal_utils.BaseError {
+	constructor(balance) {
+		super(`Omni storage balance of intents contract is too low to complete this transaction safely.`, {
+			metaMessages: [`Balance: ${balance}`],
+			name: "IntentsNearOmniAvailableBalanceTooLowError",
+			details: `The available Omni storage balance for intents contract is ${balance}, which is too low to complete this transaction safely. The balance needs to be topped up before retrying.`
+		});
+		this.balance = balance;
+	}
+};
+var OmniWithdrawalApiFeeRequestTimeoutError = class extends lampamazaza_internal_utils.BaseError {
+	constructor() {
+		super("Omni bridge withdrawal fee request timed out.", { name: "OmniWithdrawalApiFeeRequestTimeoutError" });
+	}
+};
+var InsufficientUtxoForOmniBridgeWithdrawalError = class extends lampamazaza_internal_utils.BaseError {
+	constructor(destinationChain) {
+		super("Insufficient utxo for withdrawal to a utxo chain.", {
+			metaMessages: [`Destination Chain: ${destinationChain}`],
+			name: "InsufficientUtxoForOmniBridgeWithdrawalError"
+		});
+		this.destinationChain = destinationChain;
+	}
+};
+
+//#endregion
+exports.InsufficientUtxoForOmniBridgeWithdrawalError = InsufficientUtxoForOmniBridgeWithdrawalError;
+exports.IntentsNearOmniAvailableBalanceTooLowError = IntentsNearOmniAvailableBalanceTooLowError;
+exports.InvalidFeeValueError = InvalidFeeValueError;
+exports.OmniWithdrawalApiFeeRequestTimeoutError = OmniWithdrawalApiFeeRequestTimeoutError;
+exports.TokenNotFoundInDestinationChainError = TokenNotFoundInDestinationChainError;

package/dist/src/bridges/omni-bridge/error.d.cts

@@ -0,0 +1,41 @@
+import { Chain } from "../../lib/caip2.cjs";
+import { BaseError } from "lampamazaza-internal-utils";
+
+//#region src/bridges/omni-bridge/error.d.ts
+type TokenNotFoundInDestinationChainErrorType = TokenNotFoundInDestinationChainError & {
+  name: "TokenNotFoundInDestinationChainError";
+};
+declare class TokenNotFoundInDestinationChainError extends BaseError {
+  token: string;
+  destinationChain: Chain;
+  constructor(token: string, destinationChain: Chain);
+}
+type InvalidFeeValueErrorType = InvalidFeeValueError & {
+  name: "InvalidFeeValueError";
+};
+declare class InvalidFeeValueError extends BaseError {
+  token: string;
+  constructor(token: string, value: unknown);
+}
+type IntentsNearOmniAvailableBalanceTooLowErrorType = IntentsNearOmniAvailableBalanceTooLowError & {
+  name: "IntentsNearOmniAvailableBalanceTooLowError";
+};
+declare class IntentsNearOmniAvailableBalanceTooLowError extends BaseError {
+  balance: string;
+  constructor(balance: string);
+}
+type OmniWithdrawalApiFeeRequestTimeoutErrorType = OmniWithdrawalApiFeeRequestTimeoutError & {
+  name: "OmniWithdrawalApiFeeRequestTimeoutError";
+};
+declare class OmniWithdrawalApiFeeRequestTimeoutError extends BaseError {
+  constructor();
+}
+type InsufficientUtxoForOmniBridgeWithdrawalErrorType = InsufficientUtxoForOmniBridgeWithdrawalError & {
+  name: "InsufficientUtxoForOmniBridgeWithdrawalError";
+};
+declare class InsufficientUtxoForOmniBridgeWithdrawalError extends BaseError {
+  destinationChain: Chain;
+  constructor(destinationChain: Chain);
+}
+//#endregion
+export { InsufficientUtxoForOmniBridgeWithdrawalError, InsufficientUtxoForOmniBridgeWithdrawalErrorType, IntentsNearOmniAvailableBalanceTooLowError, IntentsNearOmniAvailableBalanceTooLowErrorType, InvalidFeeValueError, InvalidFeeValueErrorType, OmniWithdrawalApiFeeRequestTimeoutError, OmniWithdrawalApiFeeRequestTimeoutErrorType, TokenNotFoundInDestinationChainError, TokenNotFoundInDestinationChainErrorType };

package/dist/src/bridges/omni-bridge/error.d.ts

@@ -0,0 +1,41 @@
+import { Chain } from "../../lib/caip2.js";
+import { BaseError } from "lampamazaza-internal-utils";
+
+//#region src/bridges/omni-bridge/error.d.ts
+type TokenNotFoundInDestinationChainErrorType = TokenNotFoundInDestinationChainError & {
+  name: "TokenNotFoundInDestinationChainError";
+};
+declare class TokenNotFoundInDestinationChainError extends BaseError {
+  token: string;
+  destinationChain: Chain;
+  constructor(token: string, destinationChain: Chain);
+}
+type InvalidFeeValueErrorType = InvalidFeeValueError & {
+  name: "InvalidFeeValueError";
+};
+declare class InvalidFeeValueError extends BaseError {
+  token: string;
+  constructor(token: string, value: unknown);
+}
+type IntentsNearOmniAvailableBalanceTooLowErrorType = IntentsNearOmniAvailableBalanceTooLowError & {
+  name: "IntentsNearOmniAvailableBalanceTooLowError";
+};
+declare class IntentsNearOmniAvailableBalanceTooLowError extends BaseError {
+  balance: string;
+  constructor(balance: string);
+}
+type OmniWithdrawalApiFeeRequestTimeoutErrorType = OmniWithdrawalApiFeeRequestTimeoutError & {
+  name: "OmniWithdrawalApiFeeRequestTimeoutError";
+};
+declare class OmniWithdrawalApiFeeRequestTimeoutError extends BaseError {
+  constructor();
+}
+type InsufficientUtxoForOmniBridgeWithdrawalErrorType = InsufficientUtxoForOmniBridgeWithdrawalError & {
+  name: "InsufficientUtxoForOmniBridgeWithdrawalError";
+};
+declare class InsufficientUtxoForOmniBridgeWithdrawalError extends BaseError {
+  destinationChain: Chain;
+  constructor(destinationChain: Chain);
+}
+//#endregion
+export { InsufficientUtxoForOmniBridgeWithdrawalError, InsufficientUtxoForOmniBridgeWithdrawalErrorType, IntentsNearOmniAvailableBalanceTooLowError, IntentsNearOmniAvailableBalanceTooLowErrorType, InvalidFeeValueError, InvalidFeeValueErrorType, OmniWithdrawalApiFeeRequestTimeoutError, OmniWithdrawalApiFeeRequestTimeoutErrorType, TokenNotFoundInDestinationChainError, TokenNotFoundInDestinationChainErrorType };

package/dist/src/bridges/omni-bridge/error.js

@@ -0,0 +1,49 @@
+import { BaseError } from "lampamazaza-internal-utils";
+
+//#region src/bridges/omni-bridge/error.ts
+var TokenNotFoundInDestinationChainError = class extends BaseError {
+	constructor(token, destinationChain) {
+		super(`The token ${token} doesn't exist in destination chain ${destinationChain}`, {
+			metaMessages: [`Token: ${token}`, `Destination Chain: ${destinationChain}`],
+			name: "TokenNotFoundInDestinationChainError"
+		});
+		this.token = token;
+		this.destinationChain = destinationChain;
+	}
+};
+var InvalidFeeValueError = class extends BaseError {
+	constructor(token, value) {
+		super(`Invalid fee value`, {
+			metaMessages: [`Token: ${token}`, `Fee value: ${value}`],
+			name: "InvalidFeeValueError"
+		});
+		this.token = token;
+	}
+};
+var IntentsNearOmniAvailableBalanceTooLowError = class extends BaseError {
+	constructor(balance) {
+		super(`Omni storage balance of intents contract is too low to complete this transaction safely.`, {
+			metaMessages: [`Balance: ${balance}`],
+			name: "IntentsNearOmniAvailableBalanceTooLowError",
+			details: `The available Omni storage balance for intents contract is ${balance}, which is too low to complete this transaction safely. The balance needs to be topped up before retrying.`
+		});
+		this.balance = balance;
+	}
+};
+var OmniWithdrawalApiFeeRequestTimeoutError = class extends BaseError {
+	constructor() {
+		super("Omni bridge withdrawal fee request timed out.", { name: "OmniWithdrawalApiFeeRequestTimeoutError" });
+	}
+};
+var InsufficientUtxoForOmniBridgeWithdrawalError = class extends BaseError {
+	constructor(destinationChain) {
+		super("Insufficient utxo for withdrawal to a utxo chain.", {
+			metaMessages: [`Destination Chain: ${destinationChain}`],
+			name: "InsufficientUtxoForOmniBridgeWithdrawalError"
+		});
+		this.destinationChain = destinationChain;
+	}
+};
+
+//#endregion
+export { InsufficientUtxoForOmniBridgeWithdrawalError, IntentsNearOmniAvailableBalanceTooLowError, InvalidFeeValueError, OmniWithdrawalApiFeeRequestTimeoutError, TokenNotFoundInDestinationChainError };

package/dist/src/bridges/omni-bridge/omni-bridge-constants.cjs

@@ -0,0 +1,12 @@
+
+//#region src/bridges/omni-bridge/omni-bridge-constants.ts
+const NEAR_NATIVE_ASSET_ID = "nep141:wrap.near";
+const OMNI_BRIDGE_CONTRACT = "omni.bridge.near";
+const MIN_ALLOWED_STORAGE_BALANCE_FOR_INTENTS_NEAR = 500000000000000000000000n;
+const MIN_GAS_AMOUNT = "37400000000000";
+
+//#endregion
+exports.MIN_ALLOWED_STORAGE_BALANCE_FOR_INTENTS_NEAR = MIN_ALLOWED_STORAGE_BALANCE_FOR_INTENTS_NEAR;
+exports.MIN_GAS_AMOUNT = MIN_GAS_AMOUNT;
+exports.NEAR_NATIVE_ASSET_ID = NEAR_NATIVE_ASSET_ID;
+exports.OMNI_BRIDGE_CONTRACT = OMNI_BRIDGE_CONTRACT;

package/dist/src/bridges/omni-bridge/omni-bridge-constants.js

@@ -0,0 +1,8 @@
+//#region src/bridges/omni-bridge/omni-bridge-constants.ts
+const NEAR_NATIVE_ASSET_ID = "nep141:wrap.near";
+const OMNI_BRIDGE_CONTRACT = "omni.bridge.near";
+const MIN_ALLOWED_STORAGE_BALANCE_FOR_INTENTS_NEAR = 500000000000000000000000n;
+const MIN_GAS_AMOUNT = "37400000000000";
+
+//#endregion
+export { MIN_ALLOWED_STORAGE_BALANCE_FOR_INTENTS_NEAR, MIN_GAS_AMOUNT, NEAR_NATIVE_ASSET_ID, OMNI_BRIDGE_CONTRACT };

package/dist/src/bridges/omni-bridge/omni-bridge-utils.cjs

@@ -0,0 +1,153 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_caip2 = require('../../lib/caip2.cjs');
+const require_omni_bridge_constants = require('./omni-bridge-constants.cjs');
+const require_poa_tokens_routable_through_omni_bridge = require('../../constants/poa-tokens-routable-through-omni-bridge.cjs');
+let lampamazaza_internal_utils = require("lampamazaza-internal-utils");
+let valibot = require("valibot");
+valibot = require_rolldown_runtime.__toESM(valibot);
+let _omni_bridge_core = require("@omni-bridge/core");
+let _omni_bridge_near = require("@omni-bridge/near");
+
+//#region src/bridges/omni-bridge/omni-bridge-utils.ts
+function createWithdrawIntentsPrimitive(params) {
+	const { contractId: tokenAccountId, standard } = lampamazaza_internal_utils.utils.parseDefuseAssetId(params.assetId);
+	(0, lampamazaza_internal_utils.assert)(standard === "nep141", "Only NEP-141 is supported");
+	const recipient = (0, _omni_bridge_core.omniAddress)(params.omniChainKind, params.destinationAddress);
+	let msg = "";
+	const ftWithdrawPayload = {
+		recipient,
+		fee: "0",
+		native_token_fee: params.nativeFee.toString()
+	};
+	if (isUtxoChain(params.omniChainKind)) {
+		(0, lampamazaza_internal_utils.assert)(params.utxoMaxGasFee !== null && params.utxoMaxGasFee > 0n, `Invalid utxo max gas fee: expected > 0, got ${params.utxoMaxGasFee}`);
+		msg = JSON.stringify({ MaxGasFee: params.utxoMaxGasFee.toString() });
+		ftWithdrawPayload.msg = msg;
+	}
+	const intents = [];
+	if (params.nativeFee > 0n) intents.push({
+		deposit_for_account_id: (0, _omni_bridge_near.calculateStorageAccountId)({
+			token: `near:${tokenAccountId}`,
+			amount: params.amount,
+			recipient,
+			fee: {
+				fee: 0n,
+				native_fee: params.nativeFee
+			},
+			sender: `near:${params.intentsContract}`,
+			msg
+		}),
+		amount: params.nativeFee.toString(),
+		contract_id: require_omni_bridge_constants.OMNI_BRIDGE_CONTRACT,
+		intent: "storage_deposit"
+	});
+	intents.push({
+		intent: "ft_withdraw",
+		token: tokenAccountId,
+		receiver_id: require_omni_bridge_constants.OMNI_BRIDGE_CONTRACT,
+		amount: params.amount.toString(),
+		storage_deposit: params.storageDepositAmount > 0n ? params.storageDepositAmount.toString() : void 0,
+		msg: JSON.stringify(ftWithdrawPayload),
+		min_gas: require_omni_bridge_constants.MIN_GAS_AMOUNT
+	});
+	return intents;
+}
+/**
+* Mapping between CAIP-2 chain identifiers and Omni Bridge ChainKind.
+* This serves as a single source of truth for bidirectional chain conversions.
+*/
+const CHAIN_MAPPINGS = [
+	[require_caip2.Chains.Ethereum, _omni_bridge_core.ChainKind.Eth],
+	[require_caip2.Chains.Base, _omni_bridge_core.ChainKind.Base],
+	[require_caip2.Chains.Arbitrum, _omni_bridge_core.ChainKind.Arb],
+	[require_caip2.Chains.Solana, _omni_bridge_core.ChainKind.Sol],
+	[require_caip2.Chains.BNB, _omni_bridge_core.ChainKind.Bnb],
+	[require_caip2.Chains.Bitcoin, _omni_bridge_core.ChainKind.Btc]
+];
+function caip2ToChainKind(network) {
+	return CHAIN_MAPPINGS.find(([chain]) => chain === network)?.[1] ?? null;
+}
+function chainKindToCaip2(network) {
+	return CHAIN_MAPPINGS.find(([_, kind]) => kind === network)?.[0] ?? null;
+}
+const UTXO_CHAINS = [_omni_bridge_core.ChainKind.Btc];
+function isUtxoChain(network) {
+	return UTXO_CHAINS.includes(network);
+}
+function poaContractIdToChainKind(contractId) {
+	return require_poa_tokens_routable_through_omni_bridge.POA_TOKENS_ROUTABLE_THROUGH_OMNI_BRIDGE[contractId] ?? null;
+}
+function validateOmniToken(nearAddress) {
+	if (nearAddress.endsWith(".testnet")) return false;
+	return (0, _omni_bridge_core.isBridgeToken)(nearAddress);
+}
+async function getAccountOmniStorageBalance(nearProvider, accountId) {
+	return lampamazaza_internal_utils.utils.queryContract({
+		contractId: require_omni_bridge_constants.OMNI_BRIDGE_CONTRACT,
+		methodName: "storage_balance_of",
+		args: { account_id: accountId },
+		finality: "optimistic",
+		nearClient: nearProvider,
+		schema: valibot.union([valibot.null(), valibot.object({
+			total: valibot.string(),
+			available: valibot.string()
+		})])
+	});
+}
+const OmniAddressSchema = valibot.custom((input) => typeof input === "string" && (input.startsWith("eth:") || input.startsWith("near:") || input.startsWith("sol:") || input.startsWith("arb:") || input.startsWith("base:") || input.startsWith("btc:") || input.startsWith("bnb:")), "Must comply with omni address schema");
+/**
+* Converts a token address from one chain to its equivalent on another chain.
+* @param nearProvider Near provider used for querying the contract
+* @param tokenAddress The source token address to convert
+* @param destinationChain The target chain for the conversion
+* @returns Promise resolving to the equivalent token address on the destination chain
+* @throws Error if source and destination chains are the same
+*
+* @example
+* // Convert NEAR token to ETH
+* const ethAddress = await getBridgedToken("near:token123", ChainKind.Ethereum)
+*/
+async function getBridgedToken(nearProvider, tokenAddress, destinationChain) {
+	return lampamazaza_internal_utils.utils.queryContract({
+		contractId: require_omni_bridge_constants.OMNI_BRIDGE_CONTRACT,
+		methodName: "get_bridged_token",
+		args: {
+			chain: _omni_bridge_core.ChainKind[destinationChain].toString(),
+			address: tokenAddress
+		},
+		finality: "optimistic",
+		nearClient: nearProvider,
+		schema: valibot.union([valibot.null(), OmniAddressSchema])
+	});
+}
+/**
+* Gets token decimals from the NEAR contract
+* @param nearProvider Near provider used for querying the contract
+* @param tokenAddress The Omni token address to check
+* @returns Promise resolving to the token's decimal information
+*/
+async function getTokenDecimals(nearProvider, tokenAddress) {
+	if ((0, _omni_bridge_core.getChain)(tokenAddress) === _omni_bridge_core.ChainKind.Near) throw new Error("Token decimals cannot be queried using NEAR addresses. Use the token's foreign chain representation (e.g., eth:0x...) to query decimals.");
+	return lampamazaza_internal_utils.utils.queryContract({
+		contractId: require_omni_bridge_constants.OMNI_BRIDGE_CONTRACT,
+		methodName: "get_token_decimals",
+		args: { address: tokenAddress },
+		finality: "optimistic",
+		nearClient: nearProvider,
+		schema: valibot.union([valibot.null(), valibot.object({
+			decimals: valibot.number(),
+			origin_decimals: valibot.number()
+		})])
+	});
+}
+
+//#endregion
+exports.caip2ToChainKind = caip2ToChainKind;
+exports.chainKindToCaip2 = chainKindToCaip2;
+exports.createWithdrawIntentsPrimitive = createWithdrawIntentsPrimitive;
+exports.getAccountOmniStorageBalance = getAccountOmniStorageBalance;
+exports.getBridgedToken = getBridgedToken;
+exports.getTokenDecimals = getTokenDecimals;
+exports.isUtxoChain = isUtxoChain;
+exports.poaContractIdToChainKind = poaContractIdToChainKind;
+exports.validateOmniToken = validateOmniToken;

package/dist/src/bridges/omni-bridge/omni-bridge-utils.js

@@ -0,0 +1,143 @@
+import { Chains } from "../../lib/caip2.js";
+import { MIN_GAS_AMOUNT, OMNI_BRIDGE_CONTRACT } from "./omni-bridge-constants.js";
+import { POA_TOKENS_ROUTABLE_THROUGH_OMNI_BRIDGE } from "../../constants/poa-tokens-routable-through-omni-bridge.js";
+import { assert, utils } from "lampamazaza-internal-utils";
+import * as v from "valibot";
+import { ChainKind, getChain, isBridgeToken, omniAddress } from "@omni-bridge/core";
+import { calculateStorageAccountId } from "@omni-bridge/near";
+
+//#region src/bridges/omni-bridge/omni-bridge-utils.ts
+function createWithdrawIntentsPrimitive(params) {
+	const { contractId: tokenAccountId, standard } = utils.parseDefuseAssetId(params.assetId);
+	assert(standard === "nep141", "Only NEP-141 is supported");
+	const recipient = omniAddress(params.omniChainKind, params.destinationAddress);
+	let msg = "";
+	const ftWithdrawPayload = {
+		recipient,
+		fee: "0",
+		native_token_fee: params.nativeFee.toString()
+	};
+	if (isUtxoChain(params.omniChainKind)) {
+		assert(params.utxoMaxGasFee !== null && params.utxoMaxGasFee > 0n, `Invalid utxo max gas fee: expected > 0, got ${params.utxoMaxGasFee}`);
+		msg = JSON.stringify({ MaxGasFee: params.utxoMaxGasFee.toString() });
+		ftWithdrawPayload.msg = msg;
+	}
+	const intents = [];
+	if (params.nativeFee > 0n) intents.push({
+		deposit_for_account_id: calculateStorageAccountId({
+			token: `near:${tokenAccountId}`,
+			amount: params.amount,
+			recipient,
+			fee: {
+				fee: 0n,
+				native_fee: params.nativeFee
+			},
+			sender: `near:${params.intentsContract}`,
+			msg
+		}),
+		amount: params.nativeFee.toString(),
+		contract_id: OMNI_BRIDGE_CONTRACT,
+		intent: "storage_deposit"
+	});
+	intents.push({
+		intent: "ft_withdraw",
+		token: tokenAccountId,
+		receiver_id: OMNI_BRIDGE_CONTRACT,
+		amount: params.amount.toString(),
+		storage_deposit: params.storageDepositAmount > 0n ? params.storageDepositAmount.toString() : void 0,
+		msg: JSON.stringify(ftWithdrawPayload),
+		min_gas: MIN_GAS_AMOUNT
+	});
+	return intents;
+}
+/**
+* Mapping between CAIP-2 chain identifiers and Omni Bridge ChainKind.
+* This serves as a single source of truth for bidirectional chain conversions.
+*/
+const CHAIN_MAPPINGS = [
+	[Chains.Ethereum, ChainKind.Eth],
+	[Chains.Base, ChainKind.Base],
+	[Chains.Arbitrum, ChainKind.Arb],
+	[Chains.Solana, ChainKind.Sol],
+	[Chains.BNB, ChainKind.Bnb],
+	[Chains.Bitcoin, ChainKind.Btc]
+];
+function caip2ToChainKind(network) {
+	return CHAIN_MAPPINGS.find(([chain]) => chain === network)?.[1] ?? null;
+}
+function chainKindToCaip2(network) {
+	return CHAIN_MAPPINGS.find(([_, kind]) => kind === network)?.[0] ?? null;
+}
+const UTXO_CHAINS = [ChainKind.Btc];
+function isUtxoChain(network) {
+	return UTXO_CHAINS.includes(network);
+}
+function poaContractIdToChainKind(contractId) {
+	return POA_TOKENS_ROUTABLE_THROUGH_OMNI_BRIDGE[contractId] ?? null;
+}
+function validateOmniToken(nearAddress) {
+	if (nearAddress.endsWith(".testnet")) return false;
+	return isBridgeToken(nearAddress);
+}
+async function getAccountOmniStorageBalance(nearProvider, accountId) {
+	return utils.queryContract({
+		contractId: OMNI_BRIDGE_CONTRACT,
+		methodName: "storage_balance_of",
+		args: { account_id: accountId },
+		finality: "optimistic",
+		nearClient: nearProvider,
+		schema: v.union([v.null(), v.object({
+			total: v.string(),
+			available: v.string()
+		})])
+	});
+}
+const OmniAddressSchema = v.custom((input) => typeof input === "string" && (input.startsWith("eth:") || input.startsWith("near:") || input.startsWith("sol:") || input.startsWith("arb:") || input.startsWith("base:") || input.startsWith("btc:") || input.startsWith("bnb:")), "Must comply with omni address schema");
+/**
+* Converts a token address from one chain to its equivalent on another chain.
+* @param nearProvider Near provider used for querying the contract
+* @param tokenAddress The source token address to convert
+* @param destinationChain The target chain for the conversion
+* @returns Promise resolving to the equivalent token address on the destination chain
+* @throws Error if source and destination chains are the same
+*
+* @example
+* // Convert NEAR token to ETH
+* const ethAddress = await getBridgedToken("near:token123", ChainKind.Ethereum)
+*/
+async function getBridgedToken(nearProvider, tokenAddress, destinationChain) {
+	return utils.queryContract({
+		contractId: OMNI_BRIDGE_CONTRACT,
+		methodName: "get_bridged_token",
+		args: {
+			chain: ChainKind[destinationChain].toString(),
+			address: tokenAddress
+		},
+		finality: "optimistic",
+		nearClient: nearProvider,
+		schema: v.union([v.null(), OmniAddressSchema])
+	});
+}
+/**
+* Gets token decimals from the NEAR contract
+* @param nearProvider Near provider used for querying the contract
+* @param tokenAddress The Omni token address to check
+* @returns Promise resolving to the token's decimal information
+*/
+async function getTokenDecimals(nearProvider, tokenAddress) {
+	if (getChain(tokenAddress) === ChainKind.Near) throw new Error("Token decimals cannot be queried using NEAR addresses. Use the token's foreign chain representation (e.g., eth:0x...) to query decimals.");
+	return utils.queryContract({
+		contractId: OMNI_BRIDGE_CONTRACT,
+		methodName: "get_token_decimals",
+		args: { address: tokenAddress },
+		finality: "optimistic",
+		nearClient: nearProvider,
+		schema: v.union([v.null(), v.object({
+			decimals: v.number(),
+			origin_decimals: v.number()
+		})])
+	});
+}
+
+//#endregion
+export { caip2ToChainKind, chainKindToCaip2, createWithdrawIntentsPrimitive, getAccountOmniStorageBalance, getBridgedToken, getTokenDecimals, isUtxoChain, poaContractIdToChainKind, validateOmniToken };