lampamazaza-new-intents-sdk 0.47.1

package/dist/src/sdk.d.ts

@@ -0,0 +1,231 @@
+import { IntentHash, IntentPrimitive, MultiPayload } from "./intents/shared-types.js";
+import { IIntentSigner } from "./intents/interfaces/intent-signer.js";
+import { BatchWithdrawalResult, Bridge, CreateWithdrawalCompletionPromisesParams, FeeEstimation, IIntentsSDK, IntentPublishResult, IntentSettlementStatus, NearTxInfo, ParsedAssetInfo, PartialRPCEndpointMap, ProcessWithdrawalArgs, QuoteOptions, SignAndSendArgs, SignAndSendWithdrawalArgs, TxInfo, TxNoInfo, WithdrawalParams, WithdrawalResult } from "./shared-types.js";
+import { IIntentRelayer } from "./intents/interfaces/intent-relayer.js";
+import { ISaltManager } from "./intents/interfaces/salt-manager.js";
+import { IntentPayloadBuilder } from "./intents/intent-payload-builder.js";
+import { EnvConfig, ILogger, NearIntentsEnv } from "lampamazaza-internal-utils";
+
+//#region src/sdk.d.ts
+interface IntentsSDKConfig {
+  /**
+   * Environment configuration. Can be:
+   * - "production" or "stage" to use preset configurations
+   * - A custom EnvConfig object for private environments
+   *
+   * Defaults to "production" if not specified.
+   *
+   * @example
+   * // Use preset
+   * new IntentsSDK({ env: "production", referral: "..." });
+   *
+   * // Use custom config for private environment
+   * new IntentsSDK({
+   *   env: {
+   *     contractID: "intents.private-shard",
+   *     poaTokenFactoryContractID: "",
+   *     poaBridgeBaseURL: "",
+   *     solverRelayBaseURL: "https://private-relay.example.com",
+   *     managerConsoleBaseURL: "",
+   *     nearIntentsBaseURL: "",
+   *   },
+   *   referral: "...",
+   * });
+   */
+  env?: NearIntentsEnv | EnvConfig;
+  intentSigner?: IIntentSigner;
+  rpc?: PartialRPCEndpointMap;
+  referral: string;
+  solverRelayApiKey?: string;
+  features?: {
+    /**
+     * Route migrated POA tokens (*.omft.near) through Omni Bridge.
+     * Enable this to use Omni Bridge for POA tokens that have been migrated to the Omni infrastructure.
+     */
+    routeMigratedPoaTokensThroughOmniBridge?: boolean;
+  };
+}
+declare class IntentsSDK implements IIntentsSDK {
+  protected envConfig: EnvConfig;
+  protected referral: string;
+  protected intentRelayer: IIntentRelayer<IntentHash>;
+  protected intentSigner?: IIntentSigner;
+  protected bridges: Bridge[];
+  protected solverRelayApiKey: string | undefined;
+  protected saltManager: ISaltManager;
+  constructor(args: IntentsSDKConfig);
+  setIntentSigner(signer: IIntentSigner): void;
+  /**
+   * Create a new intent payload builder with environment context.
+   * Use this to build custom intent payloads for your API or advanced use cases.
+   *
+   * @returns A new IntentPayloadBuilder instance configured with the SDK's environment
+   *
+   * @example
+   * ```typescript
+   * // Build a custom intent payload
+   * const payload = await sdk.intentBuilder()
+   *   .setSigner('0x1234...') // User's EVM address
+   *   .setDeadline(new Date(Date.now() + 5 * 60 * 1000))
+   *   .addIntent({
+   *     intent: 'ft_withdraw',
+   *     token: 'usdc.omft.near',
+   *     amount: '1000000',
+   *     receiver_id: 'user.near'
+   *   })
+   *   .build();
+   *
+   * // Return to user for signing with their preferred method (MetaMask, etc.)
+   * return payload;
+   * ```
+   */
+  intentBuilder(): IntentPayloadBuilder;
+  /**
+   * Invalidate multiple nonces by creating and sending empty signed intents.
+   * This prevents previously created but unused intent payloads from being executed.
+   *
+   * For expirable nonces (versioned nonces with embedded deadlines), the intent's
+   * deadline is automatically set to the minimum of:
+   * 1. The nonce's embedded deadline (can't exceed this)
+   * 2. 1 minute from now (for quick invalidation when possible)
+   *
+   * @param args.nonces - Array of nonce strings to invalidate (up to 400 nonces per call, but depends on gas consumption)
+   * @param args.signer - Optional intent signer to use (defaults to SDK's configured signer)
+   * @param args.logger - Optional logger for debugging
+   *
+   * @example
+   * ```typescript
+   * // Invalidate unused nonces
+   * await sdk.invalidateNonces({
+   *   nonces: ['nonce1', 'nonce2', 'nonce3']
+   * });
+   * ```
+   */
+  invalidateNonces(args: {
+    nonces: string[];
+    signer?: IIntentSigner;
+    logger?: ILogger;
+  }): Promise<void>;
+  createWithdrawalIntents(args: {
+    withdrawalParams: WithdrawalParams;
+    feeEstimation: FeeEstimation;
+    referral?: string;
+    logger?: ILogger;
+  }): Promise<IntentPrimitive[]>;
+  estimateWithdrawalFee(args: {
+    withdrawalParams: WithdrawalParams;
+    quoteOptions?: QuoteOptions;
+    logger?: ILogger;
+  }): Promise<FeeEstimation>;
+  estimateWithdrawalFee(args: {
+    withdrawalParams: WithdrawalParams[];
+    quoteOptions?: QuoteOptions;
+    logger?: ILogger;
+  }): Promise<FeeEstimation[]>;
+  protected _estimateWithdrawalFee(args: {
+    withdrawalParams: WithdrawalParams;
+    quoteOptions?: QuoteOptions;
+    logger?: ILogger;
+  }): Promise<FeeEstimation>;
+  /**
+   * Wait for withdrawal(s) to complete on the destination chain.
+   *
+   * **Important:** Waits until the withdrawal completes, fails, or the chain-specific
+   * p99 timeout is exceeded. Use `AbortSignal.timeout()` to set a shorter timeout budget.
+   *
+   * @throws {WithdrawalWatchError} When status polling fails (timeout or consecutive errors).
+   *   Inspect `error.cause` to determine the reason.
+   * @throws {WithdrawalFailedError} When the withdrawal fails on the destination chain.
+   * @throws {DOMException} When the provided AbortSignal is aborted (name: "AbortError").
+   *
+   * @param args.withdrawalParams - Single withdrawal or array of withdrawals
+   * @param args.intentTx - The NEAR transaction info from the published intent
+   * @param args.signal - Optional AbortSignal for cancellation/timeout
+   * @param args.logger - Optional logger for debugging
+   *
+   * @example
+   * ```typescript
+   * // With timeout
+   * const result = await sdk.waitForWithdrawalCompletion({
+   *   withdrawalParams,
+   *   intentTx,
+   *   signal: AbortSignal.timeout(5 * 60 * 1000), // 5 minute timeout
+   * });
+   * ```
+   */
+  waitForWithdrawalCompletion(args: {
+    withdrawalParams: WithdrawalParams;
+    intentTx: NearTxInfo;
+    signal?: AbortSignal;
+    logger?: ILogger;
+  }): Promise<TxInfo | TxNoInfo>;
+  waitForWithdrawalCompletion(args: {
+    withdrawalParams: WithdrawalParams[];
+    intentTx: NearTxInfo;
+    signal?: AbortSignal;
+    logger?: ILogger;
+  }): Promise<Array<TxInfo | TxNoInfo>>;
+  /**
+   * Create promises that resolve when each withdrawal completes on the destination chain.
+   * Use this for granular control over handling individual withdrawals as they complete,
+   * rather than waiting for all to finish.
+   *
+   * **Important:** Each promise waits until the withdrawal completes, fails, or the
+   * chain-specific p99 timeout is exceeded. Use `AbortSignal.timeout()` to set a
+   * shorter timeout budget.
+   *
+   * @throws {WithdrawalWatchError} When status polling fails (timeout or consecutive errors).
+   *   Inspect `error.cause` to determine the reason.
+   * @throws {WithdrawalFailedError} When the withdrawal fails on the destination chain.
+   * @throws {DOMException} When the provided AbortSignal is aborted (name: "AbortError").
+   *
+   * @param params.withdrawalParams - Array of withdrawal parameters
+   * @param params.intentTx - The NEAR transaction info from the published intent
+   * @param params.signal - Optional AbortSignal for cancellation/timeout
+   * @param params.logger - Optional logger for debugging
+   * @returns Array of promises, one per withdrawal, that resolve with transaction info
+   *
+   * @example
+   * ```typescript
+   * const promises = sdk.createWithdrawalCompletionPromises({
+   *   withdrawalParams: [withdrawal1, withdrawal2],
+   *   intentTx,
+   *   signal: AbortSignal.timeout(5 * 60 * 1000), // 5 minute timeout
+   * });
+   *
+   * // Handle each withdrawal as it completes
+   * for (const promise of promises) {
+   *   promise.then((result) => console.log('Withdrawal completed:', result));
+   * }
+   * ```
+   */
+  createWithdrawalCompletionPromises(params: CreateWithdrawalCompletionPromisesParams): Array<Promise<TxInfo | TxNoInfo>>;
+  parseAssetId(assetId: string): ParsedAssetInfo;
+  sendSignedIntents(args: {
+    multiPayloads: MultiPayload[];
+    quoteHashes?: string[];
+    logger?: ILogger;
+  }): Promise<{
+    tickets: IntentHash[];
+  }>;
+  signAndSendIntent(args: SignAndSendArgs): Promise<IntentPublishResult>;
+  private withSaltRetry;
+  signAndSendWithdrawalIntent(args: SignAndSendWithdrawalArgs<WithdrawalParams> | SignAndSendWithdrawalArgs<WithdrawalParams[]>): Promise<IntentPublishResult>;
+  waitForIntentSettlement(args: {
+    intentHash: IntentHash;
+    /** AbortSignal for cancellation/timeout. Use AbortSignal.timeout(ms) for timeout. */
+    signal?: AbortSignal;
+    logger?: ILogger;
+  }): Promise<NearTxInfo>;
+  getIntentStatus({
+    intentHash,
+    logger
+  }: {
+    intentHash: IntentHash;
+    logger?: ILogger;
+  }): Promise<IntentSettlementStatus>;
+  processWithdrawal(args: ProcessWithdrawalArgs<WithdrawalParams>): Promise<WithdrawalResult>;
+  processWithdrawal(args: ProcessWithdrawalArgs<WithdrawalParams[]>): Promise<BatchWithdrawalResult>;
+}
+//#endregion
+export { IntentsSDK, IntentsSDKConfig };

package/dist/src/sdk.js

@@ -0,0 +1,433 @@
+import { FeeExceedsAmountError } from "./classes/errors.js";
+import { RouteEnum } from "./constants/route-enum.js";
+import { Chains } from "./lib/caip2.js";
+import { AuroraEngineBridge } from "./bridges/aurora-engine-bridge/aurora-engine-bridge.js";
+import { DirectBridge } from "./bridges/direct-bridge/direct-bridge.js";
+import { HotBridgeEVMChains } from "./bridges/hot-bridge/hot-bridge-chains.js";
+import { HotBridge as HotBridge$1 } from "./bridges/hot-bridge/hot-bridge.js";
+import { IntentsBridge } from "./bridges/intents-bridge/intents-bridge.js";
+import { OmniBridge } from "./bridges/omni-bridge/omni-bridge.js";
+import { PoaBridge } from "./bridges/poa-bridge/poa-bridge.js";
+import { PUBLIC_EVM_RPC_URLS, PUBLIC_STELLAR_RPC_URLS } from "./constants/public-rpc-urls.js";
+import { VersionedNonceBuilder, saltedNonceSchema } from "./intents/expirable-nonce.js";
+import { DEFAULT_DEADLINE_MS } from "./intents/intent-payload-factory.js";
+import { IntentExecuter } from "./intents/intent-executer-impl/intent-executer.js";
+import { IntentRelayerPublic } from "./intents/intent-relayer-impl/intent-relayer-public.js";
+import { noopIntentSigner } from "./intents/intent-signer-impl/intent-signer-noop.js";
+import { zip } from "./lib/array.js";
+import { configureEvmRpcUrls, configureStellarRpcUrls } from "./lib/configure-rpc-config.js";
+import { createWithdrawalIdentifiers, watchWithdrawal } from "./core/withdrawal-watcher.js";
+import { SaltManager } from "./intents/salt-manager.js";
+import { IntentPayloadBuilder } from "./intents/intent-payload-builder.js";
+import { PUBLIC_NEAR_RPC_URLS, RelayPublishError, assert, nearFailoverRpcProvider, resolveEnvConfig, solverRelay } from "lampamazaza-internal-utils";
+import { HotBridge } from "@hot-labs/omni-sdk";
+import { stringify } from "viem";
+import * as v from "valibot";
+
+//#region src/sdk.ts
+var IntentsSDK = class {
+	constructor(args) {
+		this.envConfig = resolveEnvConfig(args.env);
+		this.referral = args.referral;
+		this.solverRelayApiKey = args.solverRelayApiKey;
+		const nearRpcUrls = args.rpc?.[Chains.Near] ?? PUBLIC_NEAR_RPC_URLS;
+		assert(nearRpcUrls.length > 0, "NEAR RPC URLs are not provided");
+		const nearProvider = nearFailoverRpcProvider({ urls: nearRpcUrls });
+		const stellarRpcUrls = configureStellarRpcUrls(PUBLIC_STELLAR_RPC_URLS, args.rpc);
+		const evmRpcUrls = configureEvmRpcUrls(PUBLIC_EVM_RPC_URLS, args.rpc, HotBridgeEVMChains);
+		/**
+		* Order of bridges matters, because the first bridge that supports the `withdrawalParams` will be used.
+		* More specific bridges should be placed before more generic ones.
+		*/
+		this.bridges = [
+			new IntentsBridge(),
+			new AuroraEngineBridge({
+				envConfig: this.envConfig,
+				nearProvider,
+				solverRelayApiKey: this.solverRelayApiKey
+			}),
+			new PoaBridge({
+				envConfig: this.envConfig,
+				routeMigratedPoaTokensThroughOmniBridge: args.features?.routeMigratedPoaTokensThroughOmniBridge
+			}),
+			new HotBridge$1({
+				envConfig: this.envConfig,
+				solverRelayApiKey: this.solverRelayApiKey,
+				hotSdk: new HotBridge({
+					logger: console,
+					evmRpc: evmRpcUrls,
+					nearRpc: nearRpcUrls,
+					stellarRpc: stellarRpcUrls.soroban,
+					stellarHorizonRpc: stellarRpcUrls.horizon,
+					async executeNearTransaction() {
+						throw new Error("not implemented");
+					}
+				})
+			}),
+			new OmniBridge({
+				envConfig: this.envConfig,
+				nearProvider,
+				solverRelayApiKey: this.solverRelayApiKey,
+				routeMigratedPoaTokensThroughOmniBridge: args.features?.routeMigratedPoaTokensThroughOmniBridge
+			}),
+			new DirectBridge({
+				envConfig: this.envConfig,
+				nearProvider,
+				solverRelayApiKey: this.solverRelayApiKey
+			})
+		];
+		this.intentRelayer = new IntentRelayerPublic({
+			envConfig: this.envConfig,
+			solverRelayApiKey: this.solverRelayApiKey
+		});
+		this.intentSigner = args.intentSigner;
+		this.saltManager = new SaltManager({
+			envConfig: this.envConfig,
+			nearProvider
+		});
+	}
+	setIntentSigner(signer) {
+		this.intentSigner = signer;
+	}
+	/**
+	* Create a new intent payload builder with environment context.
+	* Use this to build custom intent payloads for your API or advanced use cases.
+	*
+	* @returns A new IntentPayloadBuilder instance configured with the SDK's environment
+	*
+	* @example
+	* ```typescript
+	* // Build a custom intent payload
+	* const payload = await sdk.intentBuilder()
+	*   .setSigner('0x1234...') // User's EVM address
+	*   .setDeadline(new Date(Date.now() + 5 * 60 * 1000))
+	*   .addIntent({
+	*     intent: 'ft_withdraw',
+	*     token: 'usdc.omft.near',
+	*     amount: '1000000',
+	*     receiver_id: 'user.near'
+	*   })
+	*   .build();
+	*
+	* // Return to user for signing with their preferred method (MetaMask, etc.)
+	* return payload;
+	* ```
+	*/
+	intentBuilder() {
+		return new IntentPayloadBuilder({
+			envConfig: this.envConfig,
+			saltManager: this.saltManager
+		});
+	}
+	/**
+	* Invalidate multiple nonces by creating and sending empty signed intents.
+	* This prevents previously created but unused intent payloads from being executed.
+	*
+	* For expirable nonces (versioned nonces with embedded deadlines), the intent's
+	* deadline is automatically set to the minimum of:
+	* 1. The nonce's embedded deadline (can't exceed this)
+	* 2. 1 minute from now (for quick invalidation when possible)
+	*
+	* @param args.nonces - Array of nonce strings to invalidate (up to 400 nonces per call, but depends on gas consumption)
+	* @param args.signer - Optional intent signer to use (defaults to SDK's configured signer)
+	* @param args.logger - Optional logger for debugging
+	*
+	* @example
+	* ```typescript
+	* // Invalidate unused nonces
+	* await sdk.invalidateNonces({
+	*   nonces: ['nonce1', 'nonce2', 'nonce3']
+	* });
+	* ```
+	*/
+	async invalidateNonces(args) {
+		if (args.nonces.length === 0) return;
+		const intentSigner = args.signer ?? this.intentSigner;
+		assert(intentSigner != null, "Intent signer is not provided");
+		const signedIntents = await Promise.all(args.nonces.map(async (nonce) => {
+			const builder = this.intentBuilder().setNonce(nonce);
+			try {
+				const decoded = VersionedNonceBuilder.decodeNonce(nonce);
+				if (v.is(saltedNonceSchema, decoded.value)) {
+					const nonceDeadlineMs = Number(decoded.value.inner.deadline / 1000000n);
+					const nonceDeadline = new Date(nonceDeadlineMs);
+					const oneMinuteFromNow = new Date(Date.now() + DEFAULT_DEADLINE_MS);
+					const deadline = oneMinuteFromNow < nonceDeadline ? oneMinuteFromNow : nonceDeadline;
+					builder.setDeadline(deadline);
+				} else args.logger?.warn?.("Decoded nonce has unexpected structure, using default deadline");
+			} catch {}
+			const { signed } = await builder.buildAndSign(intentSigner);
+			return signed;
+		}));
+		await this.intentRelayer.publishIntents({
+			multiPayloads: signedIntents,
+			quoteHashes: []
+		}, { logger: args.logger });
+	}
+	async createWithdrawalIntents(args) {
+		for (const bridge of this.bridges) if (await bridge.supports(args.withdrawalParams)) {
+			const actualAmount = args.withdrawalParams.feeInclusive ? args.withdrawalParams.amount - args.feeEstimation.amount : args.withdrawalParams.amount;
+			await bridge.validateWithdrawal({
+				assetId: args.withdrawalParams.assetId,
+				amount: actualAmount,
+				destinationAddress: args.withdrawalParams.destinationAddress,
+				feeEstimation: args.feeEstimation,
+				routeConfig: args.withdrawalParams.routeConfig,
+				logger: args.logger
+			});
+			return bridge.createWithdrawalIntents({
+				withdrawalParams: {
+					...args.withdrawalParams,
+					amount: actualAmount
+				},
+				feeEstimation: args.feeEstimation,
+				referral: args.referral ?? this.referral
+			});
+		}
+		throw new Error(`Cannot determine bridge for withdrawal = ${stringify(args.withdrawalParams)}`);
+	}
+	estimateWithdrawalFee(args) {
+		if (!Array.isArray(args.withdrawalParams)) return this._estimateWithdrawalFee({
+			...args,
+			withdrawalParams: args.withdrawalParams
+		});
+		return Promise.all(args.withdrawalParams.map((withdrawalParams) => this._estimateWithdrawalFee({
+			...args,
+			withdrawalParams
+		})));
+	}
+	async _estimateWithdrawalFee(args) {
+		for (const bridge of this.bridges) if (await bridge.supports(args.withdrawalParams)) {
+			const fee = await bridge.estimateWithdrawalFee({
+				withdrawalParams: args.withdrawalParams,
+				quoteOptions: args.quoteOptions,
+				logger: args.logger
+			});
+			if (args.withdrawalParams.feeInclusive) {
+				if (args.withdrawalParams.amount <= fee.amount) throw new FeeExceedsAmountError(fee, args.withdrawalParams.amount);
+			}
+			return fee;
+		}
+		throw new Error(`Cannot determine bridge for withdrawal = ${stringify(args.withdrawalParams)}`);
+	}
+	async waitForWithdrawalCompletion(args) {
+		const withdrawalParamsArray = Array.isArray(args.withdrawalParams) ? args.withdrawalParams : [args.withdrawalParams];
+		const promises = this.createWithdrawalCompletionPromises({
+			withdrawalParams: withdrawalParamsArray,
+			intentTx: args.intentTx,
+			signal: args.signal,
+			logger: args.logger
+		});
+		const result = await Promise.all(promises);
+		if (Array.isArray(args.withdrawalParams)) return result;
+		assert(result.length === 1, "Unexpected result length");
+		return result[0];
+	}
+	/**
+	* Create promises that resolve when each withdrawal completes on the destination chain.
+	* Use this for granular control over handling individual withdrawals as they complete,
+	* rather than waiting for all to finish.
+	*
+	* **Important:** Each promise waits until the withdrawal completes, fails, or the
+	* chain-specific p99 timeout is exceeded. Use `AbortSignal.timeout()` to set a
+	* shorter timeout budget.
+	*
+	* @throws {WithdrawalWatchError} When status polling fails (timeout or consecutive errors).
+	*   Inspect `error.cause` to determine the reason.
+	* @throws {WithdrawalFailedError} When the withdrawal fails on the destination chain.
+	* @throws {DOMException} When the provided AbortSignal is aborted (name: "AbortError").
+	*
+	* @param params.withdrawalParams - Array of withdrawal parameters
+	* @param params.intentTx - The NEAR transaction info from the published intent
+	* @param params.signal - Optional AbortSignal for cancellation/timeout
+	* @param params.logger - Optional logger for debugging
+	* @returns Array of promises, one per withdrawal, that resolve with transaction info
+	*
+	* @example
+	* ```typescript
+	* const promises = sdk.createWithdrawalCompletionPromises({
+	*   withdrawalParams: [withdrawal1, withdrawal2],
+	*   intentTx,
+	*   signal: AbortSignal.timeout(5 * 60 * 1000), // 5 minute timeout
+	* });
+	*
+	* // Handle each withdrawal as it completes
+	* for (const promise of promises) {
+	*   promise.then((result) => console.log('Withdrawal completed:', result));
+	* }
+	* ```
+	*/
+	createWithdrawalCompletionPromises(params) {
+		const { withdrawalParams, intentTx, signal, logger } = params;
+		const widsPromise = createWithdrawalIdentifiers({
+			bridges: this.bridges,
+			withdrawalParams,
+			intentTx
+		});
+		const hotChainLastPromise = /* @__PURE__ */ new Map();
+		return withdrawalParams.map(async (_, index) => {
+			const entry = (await widsPromise)[index];
+			assert(entry != null, `Missing wid for index ${index}`);
+			if (entry.bridge.route === RouteEnum.HotBridge) {
+				const landingChain = entry.wid.landingChain;
+				const previousPromise = hotChainLastPromise.get(landingChain);
+				const sequentialPromise = (async () => {
+					if (previousPromise) await Promise.allSettled([previousPromise]);
+					return watchWithdrawal({
+						bridge: entry.bridge,
+						wid: entry.wid,
+						signal,
+						logger
+					});
+				})();
+				hotChainLastPromise.set(landingChain, sequentialPromise);
+				return sequentialPromise;
+			}
+			return watchWithdrawal({
+				bridge: entry.bridge,
+				wid: entry.wid,
+				signal,
+				logger
+			});
+		});
+	}
+	parseAssetId(assetId) {
+		for (const bridge of this.bridges) {
+			const parsed = bridge.parseAssetId(assetId);
+			if (parsed != null) return parsed;
+		}
+		throw new Error(`Cannot determine bridge for assetId = ${assetId}`);
+	}
+	async sendSignedIntents(args) {
+		return { tickets: await this.intentRelayer.publishIntents({
+			multiPayloads: args.multiPayloads,
+			quoteHashes: args.quoteHashes ?? []
+		}, { logger: args.logger }) };
+	}
+	async signAndSendIntent(args) {
+		const intentSigner = args.signer ?? this.intentSigner;
+		assert(intentSigner != null, "Intent signer is not provided");
+		const intentExecuter = new IntentExecuter({
+			envConfig: this.envConfig,
+			logger: args.logger,
+			intentSigner,
+			intentRelayer: this.intentRelayer,
+			intentPayloadFactory: args.payload,
+			onBeforePublishIntent: args.onBeforePublishIntent
+		});
+		const { ticket } = await this.withSaltRetry(args, async (salt) => intentExecuter.signAndSendIntent({
+			intents: args.intents,
+			salt,
+			relayParams: args.relayParams,
+			signedIntents: args.signedIntents
+		}));
+		return { intentHash: ticket };
+	}
+	async withSaltRetry(args, fn) {
+		try {
+			return await fn(await this.saltManager.getCachedSalt());
+		} catch (err) {
+			if (!(err instanceof RelayPublishError && err.code === "INVALID_SALT")) throw err;
+			args.logger?.warn?.("Salt error detected. Refreshing salt and retrying");
+			return fn(await this.saltManager.refresh());
+		}
+	}
+	async signAndSendWithdrawalIntent(args) {
+		let withdrawalParamsArray;
+		let feeEstimations;
+		if (isBatchMode(args)) {
+			withdrawalParamsArray = args.withdrawalParams;
+			feeEstimations = args.feeEstimation;
+		} else {
+			withdrawalParamsArray = [args.withdrawalParams];
+			feeEstimations = [args.feeEstimation];
+		}
+		const intentsP = zip(withdrawalParamsArray, feeEstimations).map(([withdrawalParams, feeEstimation]) => {
+			return this.createWithdrawalIntents({
+				withdrawalParams,
+				feeEstimation,
+				referral: args.referral ?? this.referral,
+				logger: args.logger
+			});
+		});
+		const intents = (await Promise.all(intentsP)).flat();
+		const relayParamsFn = async () => {
+			const relayParams = args.intent?.relayParams != null ? await args.intent?.relayParams() : { quoteHashes: void 0 };
+			const quoteHashes = relayParams.quoteHashes ?? [];
+			for (const fee of feeEstimations) if (fee.quote != null) quoteHashes.push(fee.quote.quote_hash);
+			return {
+				...relayParams,
+				quoteHashes
+			};
+		};
+		return this.signAndSendIntent({
+			intents,
+			signer: args.intent?.signer,
+			onBeforePublishIntent: args.intent?.onBeforePublishIntent,
+			relayParams: relayParamsFn,
+			payload: args.intent?.payload,
+			logger: args.logger,
+			signedIntents: args.intent?.signedIntents
+		});
+	}
+	async waitForIntentSettlement(args) {
+		const { tx } = await new IntentExecuter({
+			envConfig: this.envConfig,
+			logger: args.logger,
+			intentSigner: noopIntentSigner,
+			intentRelayer: this.intentRelayer
+		}).waitForSettlement(args.intentHash, { signal: args.signal });
+		return tx;
+	}
+	async getIntentStatus({ intentHash, logger }) {
+		return solverRelay.getStatus({ intent_hash: intentHash }, {
+			baseURL: this.envConfig.solverRelayBaseURL,
+			logger,
+			solverRelayApiKey: this.solverRelayApiKey
+		});
+	}
+	async processWithdrawal(args) {
+		const withdrawalParams = Array.isArray(args.withdrawalParams) ? args.withdrawalParams : [args.withdrawalParams];
+		const feeEstimation = await (() => {
+			if (args.feeEstimation != null) return Array.isArray(args.feeEstimation) ? args.feeEstimation : [args.feeEstimation];
+			return this.estimateWithdrawalFee({
+				withdrawalParams,
+				logger: args.logger
+			});
+		})();
+		const { intentHash } = await this.signAndSendWithdrawalIntent({
+			withdrawalParams,
+			feeEstimation,
+			referral: args.referral,
+			intent: args.intent,
+			logger: args.logger
+		});
+		const intentTx = await this.waitForIntentSettlement({
+			intentHash,
+			logger: args.logger
+		});
+		const destinationTx = await this.waitForWithdrawalCompletion({
+			withdrawalParams,
+			intentTx,
+			logger: args.logger
+		});
+		if (!Array.isArray(args.withdrawalParams)) return {
+			feeEstimation: feeEstimation[0],
+			intentHash,
+			intentTx,
+			destinationTx: destinationTx[0]
+		};
+		return {
+			feeEstimation,
+			intentHash,
+			intentTx,
+			destinationTx
+		};
+	}
+};
+function isBatchMode(args) {
+	return Array.isArray(args.withdrawalParams);
+}
+
+//#endregion
+export { IntentsSDK };