@gearbox-protocol/sdk 15.1.0-next.1 → 15.1.0-next.11

package/dist/esm/new-sdk/GearboxSDK.js

@@ -14,6 +14,11 @@ import { PositionsNamespace } from "./positions/PositionsNamespace.js";
 import "./positions/index.js";
 //#region src/new-sdk/GearboxSDK.ts
 /**
+* Default {@link GearboxSDKOptions.maxStateAgeSeconds}: the fastest poll an
+* app runs, so a 30 s tick sees state no older than itself.
+**/
+const DEFAULT_MAX_STATE_AGE = 30;
+/**
 * Entry point over both sources of Gearbox data: the chain and the Gearbox
 * backend. The {@link Mode} is fixed at construction and decides which methods
 * exist.
@@ -53,12 +58,27 @@ var GearboxSDK = class {
 	#onchain;
 	#offchain;
 	#ownsOnchain = false;
+	#maxStateAgeSeconds;
+	#logger;
+	/**
+	* The banners the backend attaches to a pool opportunity or a strategy
+	* position, see {@link Notice}. Top-level because the subject is either
+	* kind of entity, so neither namespace owns it. Backend-only, hence gated
+	* by mode like every other backend read: absent in `onchain` mode.
+	**/
+	notices;
 	#attached;
+	/** The one attach in flight, shared by {@link attach} and every first read. */
+	#attaching;
+	/** One sync in flight per chain: concurrent stale reads join it. */
+	#syncing = /* @__PURE__ */ new Map();
 	constructor(options) {
-		const { mode, networks, onchain, offchain, attach, logger, maxOffchainLagSeconds = 120 } = options;
+		const { mode, networks, onchain, offchain, attach, logger, maxOffchainLagSeconds = 120, maxStateAgeSeconds = 30 } = options;
 		this.mode = mode;
 		this.networks = [...networks];
 		this.#attachOptions = attach;
+		this.#maxStateAgeSeconds = maxStateAgeSeconds;
+		this.#logger = logger;
 		const needsOnchain = mode === "onchain" || mode === "both";
 		const needsOffchain = mode === "offchain" || mode === "both";
 		if (needsOnchain && !onchain) throw new MissingSourceError(mode, "onchain");
@@ -91,19 +111,67 @@ var GearboxSDK = class {
 		this.#attached = !this.#ownsOnchain;
 		const namespaceOptions = {
 			maxOffchainLagSeconds,
+			ensureFresh: this.#onchain ? (chainIds) => this.#ensureFresh(chainIds) : void 0,
 			logger
 		};
 		this.opportunities = new OpportunitiesNamespace(this.#onchain, this.#offchain, namespaceOptions);
 		this.positions = new PositionsNamespace(this.#onchain, this.#offchain, namespaceOptions);
+		const backend = this.#offchain;
+		this.notices = backend ? (subject) => backend.notices.list(subject) : void 0;
 	}
 	/**
 	* Attaches the on-chain SDK when this instance owns one; a no-op in `offchain`
 	* mode and when an already-attached SDK was injected.
 	**/
 	async attach() {
+		return this.#ensureAttached();
+	}
+	/**
+	* The attach every async read awaits: the first caller starts it, later
+	* ones join the same promise; a rejected attach is not cached, so the next
+	* read retries.
+	**/
+	async #ensureAttached() {
 		if (this.#attached || !this.#ownsOnchain || !this.#onchain) return;
-		await this.#onchain.attach(this.#attachOptions);
-		this.#attached = true;
+		if (!this.#attaching) {
+			const onchain = this.#onchain;
+			this.#attaching = onchain.attach(this.#attachOptions).then(() => {
+				this.#attached = true;
+			}).finally(() => {
+				this.#attaching = void 0;
+			});
+		}
+		return this.#attaching;
+	}
+	/**
+	* What every on-chain leg of an async read awaits: the source attached, and
+	* the chains the read touches (all of them when unnamed) synced when their
+	* loaded state is older than `maxStateAgeSeconds`. A sync that fails leaves
+	* the previous state to be served — its age tells the consumer it is stale.
+	**/
+	async #ensureFresh(chainIds) {
+		await this.#ensureAttached();
+		const onchain = this.#onchain;
+		if (!onchain) return;
+		const wanted = chainIds && new Set(chainIds);
+		const stale = [];
+		const now = Math.floor(Date.now() / 1e3);
+		for (const chain of onchain.chains.values()) {
+			if (wanted && !wanted.has(chain.chainId)) continue;
+			if (now - Number(chain.timestamp) > this.#maxStateAgeSeconds) stale.push(chain);
+		}
+		await Promise.all(stale.map((chain) => this.#sync(chain)));
+	}
+	#sync(chain) {
+		const inFlight = this.#syncing.get(chain.chainId);
+		if (inFlight) return inFlight;
+		const sync = chain.syncState().then(() => void 0).catch((error) => {
+			this.#logger?.warn(error, `failed to sync chain ${chain.chainId}; serving state of block ${chain.currentBlock}`);
+		}).finally(() => {
+			this.#syncing.delete(chain.chainId);
+		});
+		this.#syncing.set(chain.chainId, sync);
+		return sync;
 	}
 	/**
 	* Whether the on-chain source is ready to be read from. Always `true` in
@@ -140,4 +208,4 @@ function chainsOf(configured, networks) {
 	return chains;
 }
 //#endregion
-export { GearboxSDK };
+export { DEFAULT_MAX_STATE_AGE, GearboxSDK };

package/dist/esm/new-sdk/execute/ExecuteApi.js

@@ -0,0 +1,94 @@
+//#region src/new-sdk/execute/ExecuteApi.ts
+/**
+* {@inheritDoc OpportunitiesExecute}
+**/
+var ExecuteApi = class {
+	#chainOf;
+	constructor(chainOf) {
+		this.#chainOf = chainOf;
+	}
+	/**
+	* {@inheritDoc OpportunitiesExecute.buildTx}
+	**/
+	async buildTx(request) {
+		if (!request.sim.ok) throw new Error(`cannot build a transaction from a failed ${request.kind} simulation`);
+		const sdk = this.#chainOf(request.chainId);
+		switch (request.kind) {
+			case "pool": return poolTx(sdk, request);
+			case "open": return openTx(sdk, request);
+			case "account": return accountTx(sdk, request);
+		}
+	}
+};
+function poolTx(sdk, request) {
+	const { pool, wallet, sim } = request;
+	const { tokenIn, tokenOut } = sim.preview;
+	if (request.op === "deposit") {
+		const meta = sdk.pools.getDepositMetadata(pool, tokenIn.token, tokenOut.token);
+		const result = sdk.pools.addLiquidity({
+			pool,
+			wallet,
+			collateral: tokenIn,
+			meta
+		});
+		if (!result) throw new Error(`pool ${pool} takes no deposit transaction for ${tokenIn.token} (${meta.type})`);
+		return result.tx;
+	}
+	const meta = sdk.pools.getWithdrawalMetadata(pool, tokenIn.token, tokenOut.token);
+	return sdk.pools.removeLiquidity({
+		pool,
+		wallet,
+		amount: request.op === "withdraw" ? tokenOut.balance : tokenIn.balance,
+		permit: void 0,
+		meta,
+		mode: request.op === "withdraw" ? "withdraw" : "redeem"
+	}).tx;
+}
+async function openTx(sdk, request) {
+	const { creditManager, wallet, collateral, ethAmount, sim } = request;
+	const { preview } = sim;
+	return sdk.accounts.openCA({
+		creditManager,
+		to: wallet,
+		collateral,
+		ethAmount,
+		debt: preview.debt,
+		calls: preview.calls,
+		averageQuota: preview.averageQuota,
+		minQuota: preview.minQuota,
+		permits: {},
+		referralCode: 0n,
+		rwaOptions: await openRwaOptions(sdk, request)
+	});
+}
+/**
+* The documented `openCA` contract: ask the market for its open requirements
+* and hand them back as operation args, with the caller's cached signatures
+* attached. `undefined` on non-RWA markets and when no target token is named.
+**/
+async function openRwaOptions(sdk, request) {
+	if (!request.targetToken) return;
+	const requirements = await sdk.accounts.getOpenAccountRequirements(request.wallet, request.creditManager, { tokenOutAddress: request.targetToken });
+	if (!requirements) return;
+	return {
+		type: requirements.type,
+		tokensToRegister: requirements.tokensToRegister,
+		signaturesToCache: request.signaturesToCache ?? []
+	};
+}
+async function accountTx(sdk, request) {
+	const account = await sdk.accounts.getCreditAccountData(request.creditAccount);
+	if (!account) throw new Error(`credit account not found: ${request.creditAccount}`);
+	return sdk.accounts.executeCaUpdate(account, request.sim.calls, { ethAmount: nativeValue(request.sim.operations) });
+}
+/**
+* The coin the simulation asked the wallet for, which the facade wraps out of
+* `msg.value` before running the multicall. Taken off the collateral step that
+* recorded it rather than from the caller, so it cannot disagree with what was
+* simulated.
+**/
+function nativeValue(operations) {
+	return operations.reduce((total, op) => total + (op.type === "addCollateral" ? op.value ?? 0n : 0n), 0n);
+}
+//#endregion
+export { ExecuteApi };

package/dist/esm/new-sdk/execute/index.js

@@ -0,0 +1,2 @@
+import { ExecuteApi } from "./ExecuteApi.js";
+export { ExecuteApi };

package/dist/esm/new-sdk/index.js

@@ -7,6 +7,10 @@ import { NoSourceServedError } from "./errors/NoSourceServedError.js";
 import { SourceUnavailableError } from "./errors/SourceUnavailableError.js";
 import "./errors/index.js";
 import { AbstractNamespace } from "./AbstractNamespace.js";
+import { ExecuteApi } from "./execute/ExecuteApi.js";
+import "./execute/index.js";
+import { SimulateApi } from "./simulate/SimulateApi.js";
+import "./simulate/index.js";
 import { filterResponse } from "./utils/filterResponse.js";
 import { DEFAULT_MAX_OFFCHAIN_LAG, mergeChainList, mergeChainOne } from "./utils/mergeChains.js";
 import "./utils/index.js";
@@ -14,6 +18,6 @@ import { OpportunitiesNamespace } from "./opportunities/OpportunitiesNamespace.j
 import "./opportunities/index.js";
 import { PositionsNamespace } from "./positions/PositionsNamespace.js";
 import "./positions/index.js";
-import { GearboxSDK } from "./GearboxSDK.js";
+import { DEFAULT_MAX_STATE_AGE, GearboxSDK } from "./GearboxSDK.js";
 import "./types.js";
-export { AbstractNamespace, AllSourcesFailedError, DEFAULT_MAX_OFFCHAIN_LAG, GearboxSDK, MissingSourceError, NoSourceServedError, OpportunitiesNamespace, PositionsNamespace, SourceChainMismatchError, SourceUnavailableError, assertSameChains, everyChainFailed, filterResponse, mergeChainList, mergeChainOne };
+export { AbstractNamespace, AllSourcesFailedError, DEFAULT_MAX_OFFCHAIN_LAG, DEFAULT_MAX_STATE_AGE, ExecuteApi, GearboxSDK, MissingSourceError, NoSourceServedError, OpportunitiesNamespace, PositionsNamespace, SimulateApi, SourceChainMismatchError, SourceUnavailableError, assertSameChains, everyChainFailed, filterResponse, mergeChainList, mergeChainOne };

package/dist/esm/new-sdk/opportunities/OpportunitiesNamespace.js

@@ -1,6 +1,12 @@
 import { matchesOpportunityFilter } from "../../model/opportunities.js";
 import "../../model/index.js";
+import { SourceUnavailableError } from "../errors/SourceUnavailableError.js";
+import "../errors/index.js";
 import { AbstractNamespace } from "../AbstractNamespace.js";
+import { ExecuteApi } from "../execute/ExecuteApi.js";
+import "../execute/index.js";
+import { SimulateApi } from "../simulate/SimulateApi.js";
+import "../simulate/index.js";
 import { filterResponse } from "../utils/filterResponse.js";
 import { mergeChainList, mergeChainOne } from "../utils/mergeChains.js";
 import "../utils/index.js";
@@ -18,14 +24,33 @@ var OpportunitiesNamespace = class extends AbstractNamespace {
 		pool: (onchain, offchain) => mergeChainOne(onchain, offchain, this.maxOffchainLagSeconds),
 		strategy: (onchain, offchain) => mergeChainOne(onchain, offchain, this.maxOffchainLagSeconds)
 	};
+	#simulate;
+	#execute;
 	constructor(onchain, offchain, options) {
 		super("Opportunities", onchain?.opportunities, offchain?.opportunities, options);
+		this.#simulate = onchain && new SimulateApi(onchain, options.ensureFresh);
+		this.#execute = onchain && new ExecuteApi((chainId) => onchain.chain(chainId));
+	}
+	/**
+	* {@inheritDoc OpportunitiesOnchainOnly.simulate}
+	**/
+	get simulate() {
+		if (!this.#simulate) throw new SourceUnavailableError("Opportunities", "onchain");
+		return this.#simulate;
+	}
+	/**
+	* {@inheritDoc OpportunitiesOnchainOnly.execute}
+	**/
+	get execute() {
+		if (!this.#execute) throw new SourceUnavailableError("Opportunities", "onchain");
+		return this.#execute;
 	}
 	/**
 	* {@inheritDoc OpportunitiesBase.list}
 	**/
 	async list(filter) {
 		return this.merged("list opportunities", {
+			chainIds: filter?.chainIds,
 			fromChain: (source) => source.list(filter),
 			fromBackend: (source) => source.list(filter),
 			merge: this.merge.list
@@ -36,6 +61,7 @@ var OpportunitiesNamespace = class extends AbstractNamespace {
 	**/
 	async getPool(key) {
 		return this.merged("get pool opportunity", {
+			chainIds: [key.chainId],
 			fromChain: (source) => source.getPool(key),
 			fromBackend: (source) => source.getPool(key),
 			merge: this.merge.pool
@@ -46,6 +72,7 @@ var OpportunitiesNamespace = class extends AbstractNamespace {
 	**/
 	async getStrategy(key) {
 		return this.merged("get strategy opportunity", {
+			chainIds: [key.chainId],
 			fromChain: (source) => source.getStrategy(key),
 			fromBackend: (source) => source.getStrategy(key),
 			merge: this.merge.strategy
@@ -57,12 +84,8 @@ var OpportunitiesNamespace = class extends AbstractNamespace {
 	filter(response, filter) {
 		return filterResponse(response, filter, matchesOpportunityFilter);
 	}
-	history(key) {
-		return { chart: (metric, range) => this.offchain.getHistory({
-			opportunity: key,
-			range,
-			metric
-		}) };
+	async charts(key, metrics, range) {
+		return this.offchain.getCharts(key, metrics, range);
 	}
 };
 //#endregion

package/dist/esm/new-sdk/positions/PositionsNamespace.js

@@ -22,6 +22,7 @@ var PositionsNamespace = class extends AbstractNamespace {
 	**/
 	async list(wallet, filter) {
 		return this.merged("list positions", {
+			chainIds: filter?.chainIds,
 			fromChain: (source) => source.list({
 				wallet,
 				filter
@@ -39,12 +40,8 @@ var PositionsNamespace = class extends AbstractNamespace {
 	filter(response, filter) {
 		return filterResponse(response, filter, matchesPositionFilter);
 	}
-	history(key) {
-		return { chart: (metric, range) => this.offchain.getHistory({
-			position: key,
-			range,
-			metric
-		}) };
+	async charts(key, metrics, range) {
+		return this.offchain.getCharts(key, metrics, range);
 	}
 };
 //#endregion

package/dist/esm/new-sdk/simulate/SimulateApi.js

@@ -0,0 +1,360 @@
+import { hexEq } from "../../sdk/utils/hex.js";
+import { MultichainConstruct } from "../../sdk/base/MultichainConstruct.js";
+import { fetchCreditAccountSlice } from "../../sdk/accounts/intents/utils/credit-account-slice.js";
+import { CreditAccountOperationsService } from "../../sdk/accounts/intents/index.js";
+import "../../sdk/index.js";
+//#region src/new-sdk/simulate/SimulateApi.ts
+/**
+* {@inheritDoc OpportunitiesSimulate}
+*
+* Holds no state of its own: it owns the mapping from the public,
+* read-model-shaped request to the engine's intent, and nothing else. All
+* protocol knowledge stays in `CreditAccountOperationsService` and
+* `PoolService`.
+*
+* A simulation names one chain, so it reads through
+* {@link MultichainConstruct.queryChain}: there is no second source to fall back
+* to, hence a chain the SDK does not cover, or one that fails the read, throws
+* rather than answering with empty metadata.
+**/
+var SimulateApi = class extends MultichainConstruct {
+	#ensureFresh;
+	constructor(sdk, ensureFresh) {
+		super(sdk);
+		this.#ensureFresh = ensureFresh;
+	}
+	async queryChain(props) {
+		await this.#ensureFresh?.([this.sdk.chain(props.network).chainId]);
+		return super.queryChain(props);
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.delayed}
+	**/
+	delayed = {
+		withdrawStrategy: (position, params) => this.#startDelayedIntent(position, params, {
+			type: "WITHDRAW",
+			amount: params.amount,
+			to: params.to,
+			tokenOut: params.tokenOut,
+			sourceToken: params.sourceToken
+		}),
+		adjustLeverage: (position, params) => this.#startDelayedIntent(position, params, {
+			type: "ADJUST_LEVERAGE",
+			targetLeverage: params.targetLeverage,
+			token: params.token
+		}),
+		finish: (position, params) => this.queryChain({
+			network: position.chainId,
+			run: async (sdk) => {
+				const intent = resumable(params.intent ?? params.claimable.intent);
+				if (!intent) return {
+					ok: false,
+					reason: "noRecordedIntent"
+				};
+				return service(sdk).finishIntent({
+					intent,
+					claimable: params.claimable,
+					creditAccount: await slice(sdk, position.creditAccount),
+					sdk,
+					slippage: params.slippage,
+					quotaReserve: params.quotaReserve
+				});
+			}
+		})
+	};
+	/**
+	* {@inheritDoc OpportunitiesSimulate.deposit}
+	**/
+	deposit(pool, params) {
+		const { marketRegister, pools } = this.sdk.chain(pool.chainId);
+		const tokenIn = params.tokenIn ?? marketRegister.findByPool(pool.pool).pool.underlying;
+		const tokenOut = lpRoute(params.tokenOut, () => pools.getDepositTokensOut(pool.pool, tokenIn));
+		if (!tokenOut) return {
+			ok: false,
+			reason: "unsupportedTokenPair"
+		};
+		const preview = pools.simulateDeposit({
+			pool: pool.pool,
+			amount: params.amount,
+			tokenIn,
+			tokenOut
+		});
+		const call = pools.addLiquidity({
+			collateral: preview.tokenIn,
+			pool: pool.pool,
+			wallet: params.wallet,
+			meta: pools.getDepositMetadata(pool.pool, tokenIn, tokenOut)
+		});
+		if (!call) return {
+			ok: false,
+			reason: "unsupportedTokenPair"
+		};
+		return {
+			ok: true,
+			operations: [],
+			preview,
+			calls: call.calls
+		};
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.withdraw}
+	**/
+	withdraw(pool, params) {
+		const { pools } = this.sdk.chain(pool.chainId);
+		const tokenIn = params.tokenIn ?? pool.pool;
+		const tokenOut = lpRoute(params.tokenOut, () => pools.getWithdrawalTokensOut(pool.pool, tokenIn));
+		if (!tokenOut) return {
+			ok: false,
+			reason: "unsupportedTokenPair"
+		};
+		const preview = pools.simulateWithdraw({
+			pool: pool.pool,
+			amount: params.amount,
+			tokenIn,
+			tokenOut
+		});
+		const { calls } = pools.removeLiquidity({
+			pool: pool.pool,
+			amount: params.amount,
+			wallet: params.wallet,
+			permit: void 0,
+			meta: pools.getWithdrawalMetadata(pool.pool, tokenIn, tokenOut),
+			mode: "withdraw"
+		});
+		return {
+			ok: true,
+			operations: [],
+			preview,
+			calls
+		};
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.redeem}
+	**/
+	redeem(pool, params) {
+		const { pools } = this.sdk.chain(pool.chainId);
+		const tokenIn = params.tokenIn ?? pool.pool;
+		const tokenOut = lpRoute(params.tokenOut, () => pools.getWithdrawalTokensOut(pool.pool, tokenIn));
+		if (!tokenOut) return {
+			ok: false,
+			reason: "unsupportedTokenPair"
+		};
+		const preview = pools.simulateRedeem({
+			pool: pool.pool,
+			amount: params.amount,
+			tokenIn,
+			tokenOut
+		});
+		const { calls } = pools.removeLiquidity({
+			pool: pool.pool,
+			amount: params.amount,
+			wallet: params.wallet,
+			permit: void 0,
+			meta: pools.getWithdrawalMetadata(pool.pool, tokenIn, tokenOut),
+			mode: "redeem"
+		});
+		return {
+			ok: true,
+			operations: [],
+			preview,
+			calls
+		};
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.openNewStrategy}
+	**/
+	async openNewStrategy(strategy, params) {
+		return this.queryChain({
+			network: strategy.chainId,
+			run: (sdk) => service(sdk).openStrategyIntent({
+				sdk,
+				creditManager: strategy.creditManager,
+				collateral: params.collateral,
+				targetToken: params.targetToken ?? strategy.targetCollateral,
+				leverage: params.leverage,
+				leftoverBalances: params.leftoverBalances,
+				slippage: params.slippage,
+				quotaReserve: params.quotaReserve
+			})
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.depositStrategy}
+	**/
+	async depositStrategy(position, params) {
+		return this.#startIntent(position, params, {
+			type: "DEPOSIT",
+			token: params.token,
+			amount: params.amount,
+			value: params.value,
+			positionToken: params.positionToken,
+			targetLeverage: params.targetLeverage
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.withdrawStrategy}
+	**/
+	async withdrawStrategy(position, params) {
+		return this.#startRoutes(position, params, {
+			type: "WITHDRAW",
+			amount: params.amount,
+			to: params.to,
+			tokenOut: params.tokenOut,
+			sourceToken: params.sourceToken
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.maxWithdraw}
+	**/
+	async maxWithdraw(position) {
+		return this.queryChain({
+			network: position.chainId,
+			run: async (sdk) => service(sdk).maxWithdraw({
+				creditAccount: await slice(sdk, position.creditAccount),
+				sdk
+			})
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.repayStrategy}
+	**/
+	async repayStrategy(position, params) {
+		return this.#startIntent(position, params, {
+			type: "REPAY",
+			token: params.token,
+			amount: params.amount,
+			value: params.value
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.maxRepay}
+	**/
+	async maxRepay(position) {
+		return this.queryChain({
+			network: position.chainId,
+			run: async (sdk) => service(sdk).maxRepay({
+				creditAccount: await slice(sdk, position.creditAccount),
+				sdk
+			})
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.adjustLeverage}
+	**/
+	async adjustLeverage(position, params) {
+		return this.#startRoutes(position, params, {
+			type: "ADJUST_LEVERAGE",
+			targetLeverage: params.targetLeverage,
+			token: params.token
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.addCollateral}
+	**/
+	async addCollateral(position, params) {
+		return this.#startIntent(position, params, {
+			type: "ADD_COLLATERAL",
+			token: params.token,
+			amount: params.amount,
+			value: params.value
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.withdrawCollateral}
+	**/
+	async withdrawCollateral(position, params) {
+		return this.#startIntent(position, params, {
+			type: "WITHDRAW_ASSET",
+			token: params.token,
+			amount: params.amount,
+			to: params.to
+		});
+	}
+	/**
+	* Shared path of the two flows that sell a position asset, and therefore have
+	* two routes to offer: one account read, one intent, both routes quoted.
+	**/
+	async #startRoutes(position, options, intent) {
+		return this.queryChain({
+			network: position.chainId,
+			run: async (sdk) => service(sdk).intentRoutes({
+				intent,
+				creditAccount: await slice(sdk, position.creditAccount),
+				sdk,
+				slippage: options.slippage,
+				quotaReserve: options.quotaReserve
+			})
+		});
+	}
+	/**
+	* Shared path of the same two flows when only the delayed route is asked for:
+	* a planner that requests a redemption instead of swapping.
+	**/
+	async #startDelayedIntent(position, options, intent) {
+		return this.queryChain({
+			network: position.chainId,
+			run: async (sdk) => service(sdk).startDelayedIntent({
+				intent,
+				creditAccount: await slice(sdk, position.creditAccount),
+				sdk,
+				slippage: options.slippage,
+				quotaReserve: options.quotaReserve
+			})
+		});
+	}
+	/**
+	* Shared path of the five flows that act on an existing account: read the
+	* account, then run the intent through the engine.
+	**/
+	async #startIntent(position, options, intent) {
+		return this.queryChain({
+			network: position.chainId,
+			run: async (sdk) => {
+				const creditAccount = await slice(sdk, position.creditAccount);
+				return service(sdk).startIntent({
+					intent,
+					creditAccount,
+					sdk,
+					slippage: options.slippage,
+					quotaReserve: options.quotaReserve
+				});
+			}
+		});
+	}
+};
+function service(sdk) {
+	return new CreditAccountOperationsService(sdk);
+}
+function slice(sdk, creditAccount) {
+	return fetchCreditAccountSlice(sdk, creditAccount);
+}
+/**
+* The operation a claim resumes, or `undefined` when there is none to resume:
+* a withdrawal requested without an intent, a compressor too old to report one,
+* or a full close, which the engine no longer previews.
+**/
+function resumable(intent) {
+	if (!intent || intent.type === "CLOSE_ACCOUNT") return;
+	return intent;
+}
+/**
+* Picks the route the operation takes out of `tokenIn`, as a value rather than
+* an exception: an unroutable or ambiguous pair is a request the caller can
+* fix, so it belongs in the `ok: false` half alongside the strategy refusals.
+*
+* A pool with no route out of the input reports it by throwing, hence the
+* catch; a requested output is checked against the list rather than trusted,
+* so that a wrong one fails here instead of deeper in call assembly.
+**/
+function lpRoute(requested, routes) {
+	let options;
+	try {
+		options = routes();
+	} catch {
+		return;
+	}
+	if (requested) return options.some((o) => hexEq(o, requested)) ? requested : void 0;
+	return options.length === 1 ? options[0] : void 0;
+}
+//#endregion
+export { SimulateApi };

package/dist/esm/new-sdk/simulate/index.js

@@ -0,0 +1,3 @@
+import { SimulateApi } from "./SimulateApi.js";
+import "./types.js";
+export { SimulateApi };