@gearbox-protocol/sdk 15.1.0-next.2 → 15.1.0-next.21

package/dist/cjs/new-sdk/liquidations/index.js

@@ -0,0 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_new_sdk_liquidations_LiquidationsNamespace = require("./LiquidationsNamespace.js");
+require("./types.js");
+exports.LiquidationsNamespace = require_new_sdk_liquidations_LiquidationsNamespace.LiquidationsNamespace;

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

@@ -1,7 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_model_opportunities = require("../../model/opportunities.js");
 require("../../model/index.js");
+const require_new_sdk_errors_SourceUnavailableError = require("../errors/SourceUnavailableError.js");
+require("../errors/index.js");
 const require_new_sdk_AbstractNamespace = require("../AbstractNamespace.js");
+const require_new_sdk_execute_ExecuteApi = require("../execute/ExecuteApi.js");
+require("../execute/index.js");
+const require_new_sdk_prepare_PrepareApi = require("../prepare/PrepareApi.js");
+require("../prepare/index.js");
 const require_new_sdk_utils_filterResponse = require("../utils/filterResponse.js");
 const require_new_sdk_utils_mergeChains = require("../utils/mergeChains.js");
 require("../utils/index.js");
@@ -19,14 +25,33 @@ var OpportunitiesNamespace = class extends require_new_sdk_AbstractNamespace.Abs
 		pool: (onchain, offchain) => require_new_sdk_utils_mergeChains.mergeChainOne(onchain, offchain, this.maxOffchainLagSeconds),
 		strategy: (onchain, offchain) => require_new_sdk_utils_mergeChains.mergeChainOne(onchain, offchain, this.maxOffchainLagSeconds)
 	};
+	#prepare;
+	#execute;
 	constructor(onchain, offchain, options) {
 		super("Opportunities", onchain?.opportunities, offchain?.opportunities, options);
+		this.#prepare = onchain && new require_new_sdk_prepare_PrepareApi.PrepareApi(onchain, options.ensureFresh);
+		this.#execute = onchain && new require_new_sdk_execute_ExecuteApi.ExecuteApi((chainId) => onchain.chain(chainId));
+	}
+	/**
+	* {@inheritDoc OpportunitiesOnchainOnly.prepare}
+	**/
+	get prepare() {
+		if (!this.#prepare) throw new require_new_sdk_errors_SourceUnavailableError.SourceUnavailableError("Opportunities", "onchain");
+		return this.#prepare;
+	}
+	/**
+	* {@inheritDoc OpportunitiesOnchainOnly.execute}
+	**/
+	get execute() {
+		if (!this.#execute) throw new require_new_sdk_errors_SourceUnavailableError.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
@@ -37,6 +62,7 @@ var OpportunitiesNamespace = class extends require_new_sdk_AbstractNamespace.Abs
 	**/
 	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
@@ -47,6 +73,7 @@ var OpportunitiesNamespace = class extends require_new_sdk_AbstractNamespace.Abs
 	**/
 	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
@@ -58,12 +85,8 @@ var OpportunitiesNamespace = class extends require_new_sdk_AbstractNamespace.Abs
 	filter(response, filter) {
 		return require_new_sdk_utils_filterResponse.filterResponse(response, filter, require_model_opportunities.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/cjs/new-sdk/positions/PositionsNamespace.js

@@ -3,8 +3,8 @@ const require_model_positions = require("../../model/positions.js");
 require("../../model/index.js");
 const require_new_sdk_AbstractNamespace = require("../AbstractNamespace.js");
 const require_new_sdk_utils_filterResponse = require("../utils/filterResponse.js");
-const require_new_sdk_utils_mergeChains = require("../utils/mergeChains.js");
 require("../utils/index.js");
+const require_new_sdk_positions_mergePositionList = require("./mergePositionList.js");
 //#region src/new-sdk/positions/PositionsNamespace.ts
 /**
 * The `positions` namespace of a {@link GearboxSDK}, see
@@ -14,7 +14,7 @@ var PositionsNamespace = class extends require_new_sdk_AbstractNamespace.Abstrac
 	/**
 	* {@inheritDoc PositionsBase.merge}
 	**/
-	merge = { list: (onchain, offchain) => require_new_sdk_utils_mergeChains.mergeChainList(onchain, offchain, this.maxOffchainLagSeconds) };
+	merge = { list: (onchain, offchain) => require_new_sdk_positions_mergePositionList.mergePositionList(onchain, offchain, this.maxOffchainLagSeconds) };
 	constructor(onchain, offchain, options) {
 		super("Positions", onchain?.positions, offchain?.positions, options);
 	}
@@ -23,6 +23,7 @@ var PositionsNamespace = class extends require_new_sdk_AbstractNamespace.Abstrac
 	**/
 	async list(wallet, filter) {
 		return this.merged("list positions", {
+			chainIds: filter?.chainIds,
 			fromChain: (source) => source.list({
 				wallet,
 				filter
@@ -40,12 +41,8 @@ var PositionsNamespace = class extends require_new_sdk_AbstractNamespace.Abstrac
 	filter(response, filter) {
 		return require_new_sdk_utils_filterResponse.filterResponse(response, filter, require_model_positions.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/cjs/new-sdk/positions/mergePositionList.js

@@ -0,0 +1,23 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_positions = require("../../model/positions.js");
+require("../../model/index.js");
+const require_new_sdk_utils_mergeChains = require("../utils/mergeChains.js");
+//#region src/new-sdk/positions/mergePositionList.ts
+function mergePositionList(onchain, offchain, maxLagSeconds) {
+	const merged = require_new_sdk_utils_mergeChains.mergeChainList(onchain, offchain, maxLagSeconds);
+	if (!merged || !offchain) return merged;
+	const backendById = new Map(offchain.data.filter((row) => row.kind === "strategy").map((row) => [require_model_positions.positionId(row), row]));
+	return {
+		...merged,
+		data: merged.data.map((row) => {
+			const backend = row.kind === "strategy" ? backendById.get(require_model_positions.positionId(row)) : void 0;
+			return backend ? {
+				...row,
+				targetCollateral: backend.targetCollateral,
+				name: backend.name
+			} : row;
+		})
+	};
+}
+//#endregion
+exports.mergePositionList = mergePositionList;

package/dist/cjs/new-sdk/prepare/PrepareApi.js

@@ -0,0 +1,337 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_utils_hex = require("../../sdk/utils/hex.js");
+const require_sdk_base_MultichainConstruct = require("../../sdk/base/MultichainConstruct.js");
+const require_sdk_accounts_intents_utils_credit_account_slice = require("../../sdk/accounts/intents/utils/credit-account-slice.js");
+const require_sdk_accounts_intents_index = require("../../sdk/accounts/intents/index.js");
+require("../../sdk/index.js");
+//#region src/new-sdk/prepare/PrepareApi.ts
+/**
+* {@inheritDoc OpportunitiesPrepare}
+*
+* 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 PrepareApi = class extends require_sdk_base_MultichainConstruct.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 OpportunitiesPrepare.finalize}
+	**/
+	async finalize(position, params) {
+		return 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 OpportunitiesPrepare.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 OpportunitiesPrepare.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 OpportunitiesPrepare.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 OpportunitiesPrepare.openNewStrategy}
+	**/
+	async openNewStrategy(strategy, params) {
+		return this.queryChain({
+			network: strategy.chainId,
+			run: (sdk) => {
+				const targetToken = params.targetToken ?? sdk.marketRegister.findCreditManager(strategy.creditManager).strategyTargetCollateral;
+				if (!targetToken) throw new Error(`credit manager ${strategy.creditManager} has no strategy target collateral`);
+				return service(sdk).openStrategyIntent({
+					sdk,
+					creditManager: strategy.creditManager,
+					collateral: params.collateral,
+					targetToken,
+					leverage: params.leverage,
+					leftoverBalances: params.leftoverBalances,
+					slippage: params.slippage,
+					quotaReserve: params.quotaReserve
+				});
+			}
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesPrepare.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 OpportunitiesPrepare.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 OpportunitiesPrepare.maxWithdraw}
+	**/
+	async maxWithdraw(position) {
+		return this.queryChain({
+			network: position.chainId,
+			run: async (sdk) => service(sdk).maxWithdraw({
+				creditAccount: await slice(sdk, position.creditAccount),
+				sdk
+			})
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesPrepare.repayStrategy}
+	**/
+	async repayStrategy(position, params) {
+		return this.#startIntent(position, params, {
+			type: "REPAY",
+			token: params.token,
+			amount: params.amount,
+			value: params.value
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesPrepare.maxRepay}
+	**/
+	async maxRepay(position) {
+		return this.queryChain({
+			network: position.chainId,
+			run: async (sdk) => service(sdk).maxRepay({
+				creditAccount: await slice(sdk, position.creditAccount),
+				sdk
+			})
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesPrepare.adjustLeverage}
+	**/
+	async adjustLeverage(position, params) {
+		return this.#startRoutes(position, params, {
+			type: "ADJUST_LEVERAGE",
+			targetLeverage: params.targetLeverage,
+			token: params.token
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesPrepare.addCollateral}
+	**/
+	async addCollateral(position, params) {
+		return this.#startIntent(position, params, {
+			type: "ADD_COLLATERAL",
+			token: params.token,
+			amount: params.amount,
+			value: params.value
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesPrepare.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 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 require_sdk_accounts_intents_index.CreditAccountOperationsService(sdk);
+}
+function slice(sdk, creditAccount) {
+	return require_sdk_accounts_intents_utils_credit_account_slice.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) => require_sdk_utils_hex.hexEq(o, requested)) ? requested : void 0;
+	return options.length === 1 ? options[0] : void 0;
+}
+//#endregion
+exports.PrepareApi = PrepareApi;

package/dist/cjs/new-sdk/prepare/index.js

@@ -0,0 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_new_sdk_prepare_PrepareApi = require("./PrepareApi.js");
+require("./types.js");
+exports.PrepareApi = require_new_sdk_prepare_PrepareApi.PrepareApi;

package/dist/cjs/new-sdk/preview/PreviewNamespace.js

@@ -0,0 +1,36 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_preview_preview_previewOperation = require("../../preview/preview/previewOperation.js");
+require("../../preview/index.js");
+//#region src/new-sdk/preview/PreviewNamespace.ts
+/**
+* {@inheritDoc Preview}
+**/
+var PreviewNamespace = class {
+	#onchain;
+	#ensureFresh;
+	#logger;
+	constructor(onchain, options) {
+		this.#onchain = onchain;
+		this.#ensureFresh = options.ensureFresh;
+		this.#logger = options.logger?.child?.({ name: "Preview" }) ?? options.logger;
+	}
+	/**
+	* {@inheritDoc Preview.previewOperation}
+	**/
+	async previewOperation(input, options) {
+		await this.#ensureFresh?.([input.chainId]);
+		const sdk = this.#onchain.chain(input.chainId);
+		return require_preview_preview_previewOperation.previewOperation({
+			sdk,
+			to: input.to,
+			calldata: input.calldata,
+			sender: input.sender,
+			value: input.value
+		}, {
+			blockNumber: options?.blockNumber,
+			logger: this.#logger
+		});
+	}
+};
+//#endregion
+exports.PreviewNamespace = PreviewNamespace;

package/dist/cjs/new-sdk/preview/index.js

@@ -0,0 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_new_sdk_preview_PreviewNamespace = require("./PreviewNamespace.js");
+require("./types.js");
+exports.PreviewNamespace = require_new_sdk_preview_PreviewNamespace.PreviewNamespace;

package/dist/cjs/new-sdk/preview/types.js

@@ -0,0 +1 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });

package/dist/cjs/new-sdk/utils/index.js

@@ -1,6 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_new_sdk_utils_filterResponse = require("./filterResponse.js");
-require("./history.js");
 const require_new_sdk_utils_mergeChains = require("./mergeChains.js");
 exports.DEFAULT_MAX_OFFCHAIN_LAG = require_new_sdk_utils_mergeChains.DEFAULT_MAX_OFFCHAIN_LAG;
 exports.filterResponse = require_new_sdk_utils_filterResponse.filterResponse;

package/dist/cjs/offchain/AbstractOffchainNamespace.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_model_history_schema = require("../model/history.schema.js");
+const require_model_charts_schema = require("../model/charts.schema.js");
 const require_model_response_schema = require("../model/response.schema.js");
 const require_offchain_errors_OffchainInvalidJsonError = require("./errors/OffchainInvalidJsonError.js");
 const require_offchain_errors_OffchainNotConfiguredError = require("./errors/OffchainNotConfiguredError.js");
@@ -65,14 +65,17 @@ var AbstractOffchainNamespace = class {
 		};
 	}
 	/**
-	* Reads one historical series. A response carrying a metric other than the
-	* requested one fails validation.
+	* Reads the charts of one subject: one series per metric named, onto the one
+	* grid that lets them be compared at an index.
 	**/
-	async readHistory(request) {
+	async readCharts(path, metrics, range) {
 		return this.get({
-			path: request.path,
-			query: { range: request.range },
-			schema: require_model_history_schema.historySeriesSchema.extend({ metric: zod_v4.z.literal(request.metric) })
+			path,
+			query: zod_v4.z.encode(require_model_charts_schema.chartQueryCodec, {
+				metrics,
+				range
+			}),
+			schema: require_model_charts_schema.chartBundleSchemaFor(metrics, range)
 		});
 	}
 	/**

package/dist/cjs/offchain/GearboxAPI.js

@@ -1,4 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_offchain_notices_OffchainNotices = require("./notices/OffchainNotices.js");
+require("./notices/index.js");
 const require_offchain_opportunities_OffchainOpportunities = require("./opportunities/OffchainOpportunities.js");
 require("./opportunities/index.js");
 const require_offchain_positions_OffchainPositions = require("./positions/OffchainPositions.js");
@@ -34,10 +36,15 @@ var GearboxAPI = class {
 	* Namespace for the positions a wallet holds.
 	**/
 	positions;
+	/**
+	* Namespace for the notices the backend attaches to entities.
+	**/
+	notices;
 	constructor(options) {
 		this.chainIds = [...options.chainIds];
 		this.opportunities = new require_offchain_opportunities_OffchainOpportunities.OffchainOpportunities(options);
 		this.positions = new require_offchain_positions_OffchainPositions.OffchainPositions(options);
+		this.notices = new require_offchain_notices_OffchainNotices.OffchainNotices(options);
 	}
 };
 //#endregion

package/dist/cjs/offchain/index.js

@@ -11,6 +11,8 @@ const require_offchain_errors_OffchainValidationError = require("./errors/Offcha
 const require_offchain_errors_readResponseBody = require("./errors/readResponseBody.js");
 require("./errors/index.js");
 const require_offchain_AbstractOffchainNamespace = require("./AbstractOffchainNamespace.js");
+const require_offchain_notices_OffchainNotices = require("./notices/OffchainNotices.js");
+require("./notices/index.js");
 const require_offchain_opportunities_OffchainOpportunities = require("./opportunities/OffchainOpportunities.js");
 require("./opportunities/index.js");
 const require_offchain_positions_OffchainPositions = require("./positions/OffchainPositions.js");
@@ -22,6 +24,7 @@ exports.GearboxAPI = require_offchain_GearboxAPI.GearboxAPI;
 exports.OffchainInvalidJsonError = require_offchain_errors_OffchainInvalidJsonError.OffchainInvalidJsonError;
 exports.OffchainNotConfiguredError = require_offchain_errors_OffchainNotConfiguredError.OffchainNotConfiguredError;
 exports.OffchainNotImplementedError = require_offchain_errors_OffchainNotImplementedError.OffchainNotImplementedError;
+exports.OffchainNotices = require_offchain_notices_OffchainNotices.OffchainNotices;
 exports.OffchainOpportunities = require_offchain_opportunities_OffchainOpportunities.OffchainOpportunities;
 exports.OffchainPositions = require_offchain_positions_OffchainPositions.OffchainPositions;
 exports.OffchainRequestFailedError = require_offchain_errors_OffchainRequestFailedError.OffchainRequestFailedError;

package/dist/cjs/offchain/notices/OffchainNotices.js

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_notices_schema = require("../../model/notices.schema.js");
+const require_offchain_AbstractOffchainNamespace = require("../AbstractOffchainNamespace.js");
+let zod_v4 = require("zod/v4");
+//#region src/offchain/notices/OffchainNotices.ts
+/**
+* Backend counterpart of `sdk.notices`: banners the backend asks a consumer to
+* show for one entity, see {@link Notice}.
+**/
+var OffchainNotices = class extends require_offchain_AbstractOffchainNamespace.AbstractOffchainNamespace {
+	#root = "/v2/notices";
+	constructor(options) {
+		super("OffchainNotices", options);
+	}
+	/**
+	* The notices of one pool opportunity or one strategy position.
+	**/
+	async list(subject) {
+		const [kind, address] = subject.kind === "pool" ? ["pool", subject.pool] : ["strategy", subject.creditAccount];
+		return this.get({
+			path: `${this.#root}/${kind}/${subject.chainId}/${address}`,
+			schema: zod_v4.z.array(require_model_notices_schema.noticeSchema)
+		});
+	}
+};
+//#endregion
+exports.OffchainNotices = OffchainNotices;

package/dist/cjs/offchain/notices/index.js

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_offchain_notices_OffchainNotices = require("./OffchainNotices.js");
+exports.OffchainNotices = require_offchain_notices_OffchainNotices.OffchainNotices;

package/dist/cjs/offchain/opportunities/OffchainOpportunities.js

@@ -44,22 +44,18 @@ var OffchainOpportunities = class extends require_offchain_AbstractOffchainNames
 		});
 	}
 	/**
-	* One historical series of one opportunity
+	* Charts of one opportunity: one series per metric, on a shared grid.
 	**/
-	async getHistory(query) {
-		return this.readHistory({
-			path: `${this.#historyRoot(query.opportunity)}/history/${query.metric}`,
-			metric: query.metric,
-			range: query.range
-		});
+	async getCharts(key, metrics, range) {
+		return this.readCharts(`${this.#chartRoot(key)}/charts`, metrics, range);
 	}
 	#poolPath(key) {
 		return `${this.#root}/pools/${key.chainId}/${key.pool}`;
 	}
 	#strategyPath(key) {
-		return `${this.#root}/strategies/${key.chainId}/${key.creditManager}/${key.targetCollateral}`;
+		return `${this.#root}/strategies/${key.chainId}/${key.creditManager}`;
 	}
-	#historyRoot(key) {
+	#chartRoot(key) {
 		return key.kind === "pool" ? this.#poolPath(key) : this.#strategyPath(key);
 	}
 };