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

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

@@ -15,6 +15,11 @@ const require_new_sdk_positions_PositionsNamespace = require("./positions/Positi
 require("./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.
@@ -54,12 +59,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 require_new_sdk_errors_MissingSourceError.MissingSourceError(mode, "onchain");
@@ -92,19 +112,67 @@ var GearboxSDK = class {
 		this.#attached = !this.#ownsOnchain;
 		const namespaceOptions = {
 			maxOffchainLagSeconds,
+			ensureFresh: this.#onchain ? (chainIds) => this.#ensureFresh(chainIds) : void 0,
 			logger
 		};
 		this.opportunities = new require_new_sdk_opportunities_OpportunitiesNamespace.OpportunitiesNamespace(this.#onchain, this.#offchain, namespaceOptions);
 		this.positions = new require_new_sdk_positions_PositionsNamespace.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
@@ -141,4 +209,5 @@ function chainsOf(configured, networks) {
 	return chains;
 }
 //#endregion
+exports.DEFAULT_MAX_STATE_AGE = DEFAULT_MAX_STATE_AGE;
 exports.GearboxSDK = GearboxSDK;

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

@@ -0,0 +1,95 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#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
+exports.ExecuteApi = ExecuteApi;

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

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

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

@@ -8,6 +8,10 @@ const require_new_sdk_errors_NoSourceServedError = require("./errors/NoSourceSer
 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_simulate_SimulateApi = require("./simulate/SimulateApi.js");
+require("./simulate/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");
@@ -20,11 +24,14 @@ require("./types.js");
 exports.AbstractNamespace = require_new_sdk_AbstractNamespace.AbstractNamespace;
 exports.AllSourcesFailedError = require_new_sdk_errors_AllSourcesFailedError.AllSourcesFailedError;
 exports.DEFAULT_MAX_OFFCHAIN_LAG = require_new_sdk_utils_mergeChains.DEFAULT_MAX_OFFCHAIN_LAG;
+exports.DEFAULT_MAX_STATE_AGE = require_new_sdk_GearboxSDK.DEFAULT_MAX_STATE_AGE;
+exports.ExecuteApi = require_new_sdk_execute_ExecuteApi.ExecuteApi;
 exports.GearboxSDK = require_new_sdk_GearboxSDK.GearboxSDK;
 exports.MissingSourceError = require_new_sdk_errors_MissingSourceError.MissingSourceError;
 exports.NoSourceServedError = require_new_sdk_errors_NoSourceServedError.NoSourceServedError;
 exports.OpportunitiesNamespace = require_new_sdk_opportunities_OpportunitiesNamespace.OpportunitiesNamespace;
 exports.PositionsNamespace = require_new_sdk_positions_PositionsNamespace.PositionsNamespace;
+exports.SimulateApi = require_new_sdk_simulate_SimulateApi.SimulateApi;
 exports.SourceChainMismatchError = require_new_sdk_errors_SourceChainMismatchError.SourceChainMismatchError;
 exports.SourceUnavailableError = require_new_sdk_errors_SourceUnavailableError.SourceUnavailableError;
 exports.assertSameChains = require_new_sdk_errors_assertSameChains.assertSameChains;

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_simulate_SimulateApi = require("../simulate/SimulateApi.js");
+require("../simulate/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)
 	};
+	#simulate;
+	#execute;
 	constructor(onchain, offchain, options) {
 		super("Opportunities", onchain?.opportunities, offchain?.opportunities, options);
+		this.#simulate = onchain && new require_new_sdk_simulate_SimulateApi.SimulateApi(onchain, options.ensureFresh);
+		this.#execute = onchain && new require_new_sdk_execute_ExecuteApi.ExecuteApi((chainId) => onchain.chain(chainId));
+	}
+	/**
+	* {@inheritDoc OpportunitiesOnchainOnly.simulate}
+	**/
+	get simulate() {
+		if (!this.#simulate) throw new require_new_sdk_errors_SourceUnavailableError.SourceUnavailableError("Opportunities", "onchain");
+		return this.#simulate;
+	}
+	/**
+	* {@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

@@ -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