lampamazaza-new-intents-sdk 0.47.1

package/dist/src/intents/intent-signer-impl/intent-signer-viem.js

@@ -0,0 +1,30 @@
+import { utils } from "lampamazaza-internal-utils";
+
+//#region src/intents/intent-signer-impl/intent-signer-viem.ts
+var IntentSignerViem = class {
+	constructor(config) {
+		this.config = config;
+	}
+	async signIntent(intent) {
+		const payload = JSON.stringify({
+			signer_id: intent.signer_id ?? this.config.accountId ?? utils.authHandleToIntentsUserId({
+				identifier: this.config.signer.address,
+				method: "evm"
+			}),
+			verifying_contract: intent.verifying_contract,
+			deadline: intent.deadline,
+			nonce: intent.nonce,
+			intents: intent.intents
+		});
+		const signature = await this.config.signer.signMessage?.({ message: payload });
+		if (signature == null) throw new Error("No signature is returned");
+		return {
+			standard: "erc191",
+			payload,
+			signature: utils.transformERC191Signature(signature)
+		};
+	}
+};
+
+//#endregion
+export { IntentSignerViem };

package/dist/src/intents/interfaces/intent-executer.d.ts

@@ -0,0 +1,2 @@
+import "../expirable-nonce.js";
+import "../../shared-types.js";

package/dist/src/intents/interfaces/intent-relayer.d.cts

@@ -0,0 +1,43 @@
+import { MultiPayload, RelayParamsDefault } from "../shared-types.cjs";
+import { NearTxInfo } from "../../shared-types.cjs";
+import { ILogger } from "lampamazaza-internal-utils";
+
+//#region src/intents/interfaces/intent-relayer.d.ts
+interface IIntentRelayer<Ticket, RelayParams = RelayParamsDefault> {
+  /**
+   * Publishes a single intent to the relayer.
+   * @param params - The relay parameters including the signed multi-payload
+   * @param ctx - Optional context with logger
+   * @returns A ticket (typically an intent hash) for tracking the intent
+   */
+  publishIntent(params: RelayParams, ctx?: {
+    logger?: ILogger;
+  }): Promise<Ticket>;
+  /**
+   * Publishes multiple intents atomically to the relayer.
+   * All intents will be executed together or not at all.
+   * @param params - Parameters including array of multi-payloads and quote hashes
+   * @param ctx - Optional context with logger
+   * @returns Array of tickets (typically intent hashes) for tracking the intents
+   */
+  publishIntents(params: {
+    multiPayloads: MultiPayload[];
+    quoteHashes: string[];
+  }, ctx?: {
+    logger?: ILogger;
+  }): Promise<Ticket[]>;
+  /**
+   * Waits for an intent to be settled on-chain.
+   * @param ticket - The ticket returned from publishIntent
+   * @param ctx - Optional context with logger and signal
+   * @returns Transaction information once settled
+   */
+  waitForSettlement(ticket: Ticket, ctx?: {
+    logger?: ILogger;
+    signal?: AbortSignal;
+  }): Promise<{
+    tx: NearTxInfo;
+  }>;
+}
+//#endregion
+export { IIntentRelayer };

package/dist/src/intents/interfaces/intent-relayer.d.ts

@@ -0,0 +1,43 @@
+import { MultiPayload, RelayParamsDefault } from "../shared-types.js";
+import { NearTxInfo } from "../../shared-types.js";
+import { ILogger } from "lampamazaza-internal-utils";
+
+//#region src/intents/interfaces/intent-relayer.d.ts
+interface IIntentRelayer<Ticket, RelayParams = RelayParamsDefault> {
+  /**
+   * Publishes a single intent to the relayer.
+   * @param params - The relay parameters including the signed multi-payload
+   * @param ctx - Optional context with logger
+   * @returns A ticket (typically an intent hash) for tracking the intent
+   */
+  publishIntent(params: RelayParams, ctx?: {
+    logger?: ILogger;
+  }): Promise<Ticket>;
+  /**
+   * Publishes multiple intents atomically to the relayer.
+   * All intents will be executed together or not at all.
+   * @param params - Parameters including array of multi-payloads and quote hashes
+   * @param ctx - Optional context with logger
+   * @returns Array of tickets (typically intent hashes) for tracking the intents
+   */
+  publishIntents(params: {
+    multiPayloads: MultiPayload[];
+    quoteHashes: string[];
+  }, ctx?: {
+    logger?: ILogger;
+  }): Promise<Ticket[]>;
+  /**
+   * Waits for an intent to be settled on-chain.
+   * @param ticket - The ticket returned from publishIntent
+   * @param ctx - Optional context with logger and signal
+   * @returns Transaction information once settled
+   */
+  waitForSettlement(ticket: Ticket, ctx?: {
+    logger?: ILogger;
+    signal?: AbortSignal;
+  }): Promise<{
+    tx: NearTxInfo;
+  }>;
+}
+//#endregion
+export { IIntentRelayer };

package/dist/src/intents/interfaces/intent-signer.d.cts

@@ -0,0 +1,8 @@
+import { IntentPayload, MultiPayload } from "../shared-types.cjs";
+
+//#region src/intents/interfaces/intent-signer.d.ts
+interface IIntentSigner {
+  signIntent(intent: IntentPayload): Promise<MultiPayload>;
+}
+//#endregion
+export { IIntentSigner };

package/dist/src/intents/interfaces/intent-signer.d.ts

@@ -0,0 +1,8 @@
+import { IntentPayload, MultiPayload } from "../shared-types.js";
+
+//#region src/intents/interfaces/intent-signer.d.ts
+interface IIntentSigner {
+  signIntent(intent: IntentPayload): Promise<MultiPayload>;
+}
+//#endregion
+export { IIntentSigner };

package/dist/src/intents/interfaces/salt-manager.d.cts

@@ -0,0 +1,9 @@
+import { Salt } from "../expirable-nonce.cjs";
+
+//#region src/intents/interfaces/salt-manager.d.ts
+interface ISaltManager {
+  getCachedSalt(): Promise<Salt>;
+  refresh(): Promise<Salt>;
+}
+//#endregion
+export { ISaltManager };

package/dist/src/intents/interfaces/salt-manager.d.ts

@@ -0,0 +1,9 @@
+import { Salt } from "../expirable-nonce.js";
+
+//#region src/intents/interfaces/salt-manager.d.ts
+interface ISaltManager {
+  getCachedSalt(): Promise<Salt>;
+  refresh(): Promise<Salt>;
+}
+//#endregion
+export { ISaltManager };

package/dist/src/intents/salt-manager.cjs

@@ -0,0 +1,74 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+let lampamazaza_internal_utils = require("lampamazaza-internal-utils");
+let _scure_base = require("@scure/base");
+let valibot = require("valibot");
+valibot = require_rolldown_runtime.__toESM(valibot);
+
+//#region src/intents/salt-manager.ts
+const SALT_TTL_MS = 300 * 1e3;
+var SaltManager = class {
+	constructor({ envConfig, nearProvider }) {
+		this.currentSalt = null;
+		this.fetchPromise = null;
+		this.lastFetchTime = 0;
+		this.intentsContract = envConfig.contractID;
+		this.nearProvider = nearProvider;
+	}
+	/**
+	* Returns the cached salt if it's valid, otherwise fetches a new one
+	* Deduplicates concurrent requests so only one fetch runs at a time
+	*/
+	async getCachedSalt() {
+		if (this.isCacheValid()) return this.currentSalt;
+		if (this.fetchPromise) return this.fetchPromise;
+		this.fetchPromise = this.fetchAndCache().finally(() => {
+			this.fetchPromise = null;
+		});
+		return this.fetchPromise;
+	}
+	/**
+	* Fetches a new salt from the contract and updates the cache
+	*/
+	async refresh() {
+		this.invalidateCache();
+		return this.getCachedSalt();
+	}
+	async fetchAndCache() {
+		try {
+			this.currentSalt = await fetchSalt(this.nearProvider, this.intentsContract);
+			this.lastFetchTime = Date.now();
+			return this.currentSalt;
+		} catch (err) {
+			this.fetchPromise = null;
+			throw new Error(`Failed to fetch salt`, { cause: err });
+		}
+	}
+	isCacheValid() {
+		return this.currentSalt != null && Date.now() - this.lastFetchTime < SALT_TTL_MS;
+	}
+	invalidateCache() {
+		this.currentSalt = null;
+		this.lastFetchTime = 0;
+	}
+};
+/**
+* Fetches the current salt from the NEAR contract
+*
+* @param nearProvider Near provider used for querying the contract
+* @param contractId The NEAR contract ID to query
+* @returns Promise resolving to the salt
+*/
+async function fetchSalt(nearProvider, contractId) {
+	const value = await lampamazaza_internal_utils.utils.queryContract({
+		contractId,
+		methodName: "current_salt",
+		args: {},
+		finality: "optimistic",
+		nearClient: nearProvider,
+		schema: valibot.string()
+	});
+	return _scure_base.hex.decode(value);
+}
+
+//#endregion
+exports.SaltManager = SaltManager;

package/dist/src/intents/salt-manager.js

@@ -0,0 +1,72 @@
+import { utils } from "lampamazaza-internal-utils";
+import { hex } from "@scure/base";
+import * as v from "valibot";
+
+//#region src/intents/salt-manager.ts
+const SALT_TTL_MS = 300 * 1e3;
+var SaltManager = class {
+	constructor({ envConfig, nearProvider }) {
+		this.currentSalt = null;
+		this.fetchPromise = null;
+		this.lastFetchTime = 0;
+		this.intentsContract = envConfig.contractID;
+		this.nearProvider = nearProvider;
+	}
+	/**
+	* Returns the cached salt if it's valid, otherwise fetches a new one
+	* Deduplicates concurrent requests so only one fetch runs at a time
+	*/
+	async getCachedSalt() {
+		if (this.isCacheValid()) return this.currentSalt;
+		if (this.fetchPromise) return this.fetchPromise;
+		this.fetchPromise = this.fetchAndCache().finally(() => {
+			this.fetchPromise = null;
+		});
+		return this.fetchPromise;
+	}
+	/**
+	* Fetches a new salt from the contract and updates the cache
+	*/
+	async refresh() {
+		this.invalidateCache();
+		return this.getCachedSalt();
+	}
+	async fetchAndCache() {
+		try {
+			this.currentSalt = await fetchSalt(this.nearProvider, this.intentsContract);
+			this.lastFetchTime = Date.now();
+			return this.currentSalt;
+		} catch (err) {
+			this.fetchPromise = null;
+			throw new Error(`Failed to fetch salt`, { cause: err });
+		}
+	}
+	isCacheValid() {
+		return this.currentSalt != null && Date.now() - this.lastFetchTime < SALT_TTL_MS;
+	}
+	invalidateCache() {
+		this.currentSalt = null;
+		this.lastFetchTime = 0;
+	}
+};
+/**
+* Fetches the current salt from the NEAR contract
+*
+* @param nearProvider Near provider used for querying the contract
+* @param contractId The NEAR contract ID to query
+* @returns Promise resolving to the salt
+*/
+async function fetchSalt(nearProvider, contractId) {
+	const value = await utils.queryContract({
+		contractId,
+		methodName: "current_salt",
+		args: {},
+		finality: "optimistic",
+		nearClient: nearProvider,
+		schema: v.string()
+	});
+	return hex.decode(value);
+}
+
+//#endregion
+export { SaltManager };

package/dist/src/intents/shared-types.d.cts

@@ -0,0 +1,20 @@
+import { Intent, MultiPayload as MultiPayload$1 } from "lampamazaza-contract-types";
+
+//#region src/intents/shared-types.d.ts
+type IntentPrimitive = Intent;
+interface IntentPayload {
+  verifying_contract: string;
+  deadline: string;
+  nonce: string;
+  intents: IntentPrimitive[];
+  signer_id: string | undefined;
+}
+type IntentPayloadFactory = (intentParams: IntentPayload) => Promise<Partial<IntentPayload>> | Partial<IntentPayload>;
+type IntentHash = string;
+interface RelayParamsDefault {
+  multiPayload: MultiPayload$1;
+  quoteHashes?: string[];
+}
+type IntentRelayParamsFactory<RelayParams = Omit<RelayParamsDefault, "multiPayload">> = () => RelayParams | Promise<RelayParams>;
+//#endregion
+export { IntentHash, IntentPayload, IntentPayloadFactory, IntentPrimitive, IntentRelayParamsFactory, type MultiPayload$1 as MultiPayload, RelayParamsDefault };

package/dist/src/intents/shared-types.d.ts

@@ -0,0 +1,20 @@
+import { Intent, MultiPayload as MultiPayload$1 } from "lampamazaza-contract-types";
+
+//#region src/intents/shared-types.d.ts
+type IntentPrimitive = Intent;
+interface IntentPayload {
+  verifying_contract: string;
+  deadline: string;
+  nonce: string;
+  intents: IntentPrimitive[];
+  signer_id: string | undefined;
+}
+type IntentPayloadFactory = (intentParams: IntentPayload) => Promise<Partial<IntentPayload>> | Partial<IntentPayload>;
+type IntentHash = string;
+interface RelayParamsDefault {
+  multiPayload: MultiPayload$1;
+  quoteHashes?: string[];
+}
+type IntentRelayParamsFactory<RelayParams = Omit<RelayParamsDefault, "multiPayload">> = () => RelayParams | Promise<RelayParams>;
+//#endregion
+export { IntentHash, IntentPayload, IntentPayloadFactory, IntentPrimitive, IntentRelayParamsFactory, type MultiPayload$1 as MultiPayload, RelayParamsDefault };

package/dist/src/lib/array.cjs

@@ -0,0 +1,11 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+let lampamazaza_internal_utils = require("lampamazaza-internal-utils");
+
+//#region src/lib/array.ts
+function zip(arr1, arr2) {
+	(0, lampamazaza_internal_utils.assert)(arr1.length === arr2.length, "Arrays must have the same length");
+	return arr1.map((v, i) => [v, arr2[i]]);
+}
+
+//#endregion
+exports.zip = zip;

package/dist/src/lib/array.js

@@ -0,0 +1,10 @@
+import { assert } from "lampamazaza-internal-utils";
+
+//#region src/lib/array.ts
+function zip(arr1, arr2) {
+	assert(arr1.length === arr2.length, "Arrays must have the same length");
+	return arr1.map((v, i) => [v, arr2[i]]);
+}
+
+//#endregion
+export { zip };

package/dist/src/lib/caip2.cjs

@@ -0,0 +1,50 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+let lampamazaza_internal_utils = require("lampamazaza-internal-utils");
+
+//#region src/lib/caip2.ts
+/**
+* CAIP2 identifiers
+*/
+const Chains = {
+	Bitcoin: "bip122:000000000019d6689c085ae165831e93",
+	BitcoinCash: "bip122:000000000000000000651ef99cb9fcbe",
+	Zcash: "bip122:00040fe8ec8471911baa1db1266ea15d",
+	Dogecoin: "bip122:1a91e3dace36e2be3bf030a65679fe82",
+	Litecoin: "bip122:12a765e31ffd4059bada1e25190f6e98",
+	Ethereum: "eip155:1",
+	Optimism: "eip155:10",
+	BNB: "eip155:56",
+	Gnosis: "eip155:100",
+	Polygon: "eip155:137",
+	Monad: "eip155:143",
+	LayerX: "eip155:196",
+	Adi: "eip155:36900",
+	Base: "eip155:8453",
+	Arbitrum: "eip155:42161",
+	Avalanche: "eip155:43114",
+	Berachain: "eip155:80085",
+	Near: "near:mainnet",
+	Solana: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+	Tron: "tron:27Lqcw",
+	XRPL: "xrpl:0",
+	TON: "tvm:-239",
+	Sui: "sui:mainnet",
+	Aptos: "aptos:mainnet",
+	Stellar: "stellar:pubnet",
+	Cardano: "cip34:1-764824073",
+	Starknet: "starknet:SN_MAIN",
+	Plasma: "eip155:9745",
+	Scroll: "eip155:534352"
+};
+function getEIP155ChainId(chain) {
+	(0, lampamazaza_internal_utils.assert)(chain.startsWith("eip155:"), "Chain is not an EIP-155 chain");
+	const chainIdStr = chain.slice(7);
+	(0, lampamazaza_internal_utils.assert)(chainIdStr.length > 0, "Chain is not an EIP-155 chain");
+	const chainId = Number(chainIdStr);
+	(0, lampamazaza_internal_utils.assert)(!Number.isNaN(chainId), "Chain is not an EIP-155 chain");
+	return chainId;
+}
+
+//#endregion
+exports.Chains = Chains;
+exports.getEIP155ChainId = getEIP155ChainId;

package/dist/src/lib/caip2.d.cts

@@ -0,0 +1,38 @@
+//#region src/lib/caip2.d.ts
+/**
+ * CAIP2 identifiers
+ */
+declare const Chains: {
+  readonly Bitcoin: "bip122:000000000019d6689c085ae165831e93";
+  readonly BitcoinCash: "bip122:000000000000000000651ef99cb9fcbe";
+  readonly Zcash: "bip122:00040fe8ec8471911baa1db1266ea15d";
+  readonly Dogecoin: "bip122:1a91e3dace36e2be3bf030a65679fe82";
+  readonly Litecoin: "bip122:12a765e31ffd4059bada1e25190f6e98";
+  readonly Ethereum: "eip155:1";
+  readonly Optimism: "eip155:10";
+  readonly BNB: "eip155:56";
+  readonly Gnosis: "eip155:100";
+  readonly Polygon: "eip155:137";
+  readonly Monad: "eip155:143";
+  readonly LayerX: "eip155:196";
+  readonly Adi: "eip155:36900";
+  readonly Base: "eip155:8453";
+  readonly Arbitrum: "eip155:42161";
+  readonly Avalanche: "eip155:43114";
+  readonly Berachain: "eip155:80085";
+  readonly Near: "near:mainnet";
+  readonly Solana: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+  readonly Tron: "tron:27Lqcw";
+  readonly XRPL: "xrpl:0";
+  readonly TON: "tvm:-239";
+  readonly Sui: "sui:mainnet";
+  readonly Aptos: "aptos:mainnet";
+  readonly Stellar: "stellar:pubnet";
+  readonly Cardano: "cip34:1-764824073";
+  readonly Starknet: "starknet:SN_MAIN";
+  readonly Plasma: "eip155:9745";
+  readonly Scroll: "eip155:534352";
+};
+type Chain = (typeof Chains)[keyof typeof Chains];
+//#endregion
+export { Chain, Chains };

package/dist/src/lib/caip2.d.ts

@@ -0,0 +1,38 @@
+//#region src/lib/caip2.d.ts
+/**
+ * CAIP2 identifiers
+ */
+declare const Chains: {
+  readonly Bitcoin: "bip122:000000000019d6689c085ae165831e93";
+  readonly BitcoinCash: "bip122:000000000000000000651ef99cb9fcbe";
+  readonly Zcash: "bip122:00040fe8ec8471911baa1db1266ea15d";
+  readonly Dogecoin: "bip122:1a91e3dace36e2be3bf030a65679fe82";
+  readonly Litecoin: "bip122:12a765e31ffd4059bada1e25190f6e98";
+  readonly Ethereum: "eip155:1";
+  readonly Optimism: "eip155:10";
+  readonly BNB: "eip155:56";
+  readonly Gnosis: "eip155:100";
+  readonly Polygon: "eip155:137";
+  readonly Monad: "eip155:143";
+  readonly LayerX: "eip155:196";
+  readonly Adi: "eip155:36900";
+  readonly Base: "eip155:8453";
+  readonly Arbitrum: "eip155:42161";
+  readonly Avalanche: "eip155:43114";
+  readonly Berachain: "eip155:80085";
+  readonly Near: "near:mainnet";
+  readonly Solana: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+  readonly Tron: "tron:27Lqcw";
+  readonly XRPL: "xrpl:0";
+  readonly TON: "tvm:-239";
+  readonly Sui: "sui:mainnet";
+  readonly Aptos: "aptos:mainnet";
+  readonly Stellar: "stellar:pubnet";
+  readonly Cardano: "cip34:1-764824073";
+  readonly Starknet: "starknet:SN_MAIN";
+  readonly Plasma: "eip155:9745";
+  readonly Scroll: "eip155:534352";
+};
+type Chain = (typeof Chains)[keyof typeof Chains];
+//#endregion
+export { Chain, Chains };

package/dist/src/lib/caip2.js

@@ -0,0 +1,48 @@
+import { assert } from "lampamazaza-internal-utils";
+
+//#region src/lib/caip2.ts
+/**
+* CAIP2 identifiers
+*/
+const Chains = {
+	Bitcoin: "bip122:000000000019d6689c085ae165831e93",
+	BitcoinCash: "bip122:000000000000000000651ef99cb9fcbe",
+	Zcash: "bip122:00040fe8ec8471911baa1db1266ea15d",
+	Dogecoin: "bip122:1a91e3dace36e2be3bf030a65679fe82",
+	Litecoin: "bip122:12a765e31ffd4059bada1e25190f6e98",
+	Ethereum: "eip155:1",
+	Optimism: "eip155:10",
+	BNB: "eip155:56",
+	Gnosis: "eip155:100",
+	Polygon: "eip155:137",
+	Monad: "eip155:143",
+	LayerX: "eip155:196",
+	Adi: "eip155:36900",
+	Base: "eip155:8453",
+	Arbitrum: "eip155:42161",
+	Avalanche: "eip155:43114",
+	Berachain: "eip155:80085",
+	Near: "near:mainnet",
+	Solana: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+	Tron: "tron:27Lqcw",
+	XRPL: "xrpl:0",
+	TON: "tvm:-239",
+	Sui: "sui:mainnet",
+	Aptos: "aptos:mainnet",
+	Stellar: "stellar:pubnet",
+	Cardano: "cip34:1-764824073",
+	Starknet: "starknet:SN_MAIN",
+	Plasma: "eip155:9745",
+	Scroll: "eip155:534352"
+};
+function getEIP155ChainId(chain) {
+	assert(chain.startsWith("eip155:"), "Chain is not an EIP-155 chain");
+	const chainIdStr = chain.slice(7);
+	assert(chainIdStr.length > 0, "Chain is not an EIP-155 chain");
+	const chainId = Number(chainIdStr);
+	assert(!Number.isNaN(chainId), "Chain is not an EIP-155 chain");
+	return chainId;
+}
+
+//#endregion
+export { Chains, getEIP155ChainId };

package/dist/src/lib/configure-rpc-config.cjs

@@ -0,0 +1,20 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_caip2 = require('./caip2.cjs');
+const require_object = require('./object.cjs');
+let lampamazaza_internal_utils = require("lampamazaza-internal-utils");
+
+//#region src/lib/configure-rpc-config.ts
+function configureEvmRpcUrls(defaultRpcUrls, userRpcUrls, supportedChains) {
+	const evmRpcUrls = Object.fromEntries(Object.entries(require_object.pick(Object.assign({}, defaultRpcUrls, userRpcUrls ?? {}), supportedChains)).map(([caip2, urls]) => [require_caip2.getEIP155ChainId(caip2), urls]));
+	for (const [chainId, urls] of Object.entries(evmRpcUrls)) (0, lampamazaza_internal_utils.assert)(urls.length > 0, `EVM RPC URLs for chain ${chainId} are not provided`);
+	return evmRpcUrls;
+}
+function configureStellarRpcUrls(defaultRpcUrls, userRpcUrls) {
+	const stellarRpcUrls = Object.assign({}, defaultRpcUrls, userRpcUrls?.[require_caip2.Chains.Stellar] ?? {});
+	for (const [key, value] of Object.entries(stellarRpcUrls)) (0, lampamazaza_internal_utils.assert)(value.length > 0, `Stellar RPC URL for ${key} is not provided`);
+	return stellarRpcUrls;
+}
+
+//#endregion
+exports.configureEvmRpcUrls = configureEvmRpcUrls;
+exports.configureStellarRpcUrls = configureStellarRpcUrls;

package/dist/src/lib/configure-rpc-config.js

@@ -0,0 +1,18 @@
+import { Chains, getEIP155ChainId } from "./caip2.js";
+import { pick } from "./object.js";
+import { assert } from "lampamazaza-internal-utils";
+
+//#region src/lib/configure-rpc-config.ts
+function configureEvmRpcUrls(defaultRpcUrls, userRpcUrls, supportedChains) {
+	const evmRpcUrls = Object.fromEntries(Object.entries(pick(Object.assign({}, defaultRpcUrls, userRpcUrls ?? {}), supportedChains)).map(([caip2, urls]) => [getEIP155ChainId(caip2), urls]));
+	for (const [chainId, urls] of Object.entries(evmRpcUrls)) assert(urls.length > 0, `EVM RPC URLs for chain ${chainId} are not provided`);
+	return evmRpcUrls;
+}
+function configureStellarRpcUrls(defaultRpcUrls, userRpcUrls) {
+	const stellarRpcUrls = Object.assign({}, defaultRpcUrls, userRpcUrls?.[Chains.Stellar] ?? {});
+	for (const [key, value] of Object.entries(stellarRpcUrls)) assert(value.length > 0, `Stellar RPC URL for ${key} is not provided`);
+	return stellarRpcUrls;
+}
+
+//#endregion
+export { configureEvmRpcUrls, configureStellarRpcUrls };