@gearbox-protocol/sdk 17.2.0-next.1 → 17.2.1

package/dist/esm/onchain/accounts/intents/maxBorrow.js

@@ -20,18 +20,16 @@ import { collateralValuation } from "./collateral-valuation.js";
 * prices, under its liquidation threshold, capped by the quota the borrow
 * buys for it, all of which is {@link collateralValuation}'s business. The ceiling
 * is then held to what the market will actually lend: the pool's free
-* liquidity, the manager's own allowance, the facade's `maxDebt` and the
-* remaining quota of the strategy target collateral, whichever binds first.
+* liquidity, the manager's own allowance and the facade's `maxDebt`, whichever
+* binds first.
 *
-* The facade's `minDebt` is not applied to the collateral's own ceiling. It
-* is a floor, and a ceiling answered as `0n` because the collateral is too
-* small for this market would tell a form nothing about what it is holding —
-* the number a user needs to see is the one they are short of. Collateral
-* that carries something therefore answers with it, whether or not the market
-* would lend that little; a loan under the floor is refused by `borrow`
-* itself, with `debtOutOfRange` naming both ends. A market whose own capacity
-* is under `minDebt` is different: `maxStrategyBorrowAmount` answers `0n`,
-* because no loan of any size exists there.
+* The facade's `minDebt` is deliberately not applied. It is a floor, and a
+* ceiling answered as `0n` because the collateral is too small for this market
+* would tell a form nothing about what it is holding — the number a user needs
+* to see is the one they are short of. Collateral that carries something
+* therefore answers with it, whether or not the market would lend that little;
+* a loan under the floor is refused by `borrow` itself, with `debtOutOfRange`
+* naming both ends.
 *
 * Nothing is fetched or simulated — the account does not exist yet and every
 * input is loaded market state, so a form can call this on each keystroke.
@@ -81,7 +79,7 @@ function maxBorrow(props) {
 	const weighted = valuation.checkedUsd(holding) * valuation.lt(collateralToken);
 	const backed = quotas.some((q) => eq(q.token, collateralToken)) ? BigIntMath.min(valuation.quotaValue(holding), weighted) : weighted;
 	if (backed <= 0n) return 0n;
-	const ceiling = BigIntMath.min(priceOracle.safeConvertFromUSD(underlying, backed / targetHF).value, suite.maxStrategyBorrowAmount().amount.value);
+	const ceiling = BigIntMath.min(priceOracle.safeConvertFromUSD(underlying, backed / targetHF).value, suite.maxBorrowAmount().amount.value);
 	const unwrapsPayout = !!rwaAsset && eq(borrowToken, rwaAsset);
 	return eq(borrowToken, underlying) ? ceiling : unwrapsPayout ? toTargetDecimals(ceiling, underlying, borrowToken, sdk) : priceOracle.safeConvert(underlying, borrowToken, ceiling).value;
 }

package/dist/esm/onchain/accounts/intents/testing/sdk-mock.js

@@ -198,7 +198,6 @@ function buildMockSdk(args) {
 		creditOperationMarket: CreditSuite.prototype.creditOperationMarket,
 		isForbidden: CreditSuite.prototype.isForbidden,
 		maxBorrowAmount: CreditSuite.prototype.maxBorrowAmount,
-		maxStrategyBorrowAmount: CreditSuite.prototype.maxStrategyBorrowAmount,
 		creditManager: {
 			address: args.creditManager,
 			liquidationThresholds,

package/dist/esm/onchain/chain/chains.js

@@ -68,6 +68,7 @@ const chains = {
 			"0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": "ETH",
 			"0x18084fbA666a33d37592fA2633fD49a74DD93a88": "BTC",
 			"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": "Stable",
+			"0xCAcd6fd266aF91b8AeD52aCCc382b4e165586E29": "Stable",
 			"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599": "BTC"
 		}),
 		rwaTokens: new AddressSet([

package/dist/esm/onchain/market/credit/CreditSuite.js

@@ -18,7 +18,7 @@ import { isAddressEqual } from "viem";
 /**
 * Amount of underlying seeded into each pool at market creation to protect
 * from inflation attacks, in raw token units. A suite whose
-* {@link CreditSuite.maxStrategyBorrowAmount} is at or below this is treated as
+* {@link CreditSuite.maxBorrowAmount} is at or below this is treated as
 * having nothing left to lend.
 **/
 const MIN_STRATEGY_BORROW_AMOUNT = 100000n;
@@ -281,7 +281,7 @@ var CreditSuite = class extends SDKConstruct {
 		return this.forbiddenTokens.some((f) => isAddressEqual(f, token));
 	}
 	/**
-	* Largest debt this credit manager will hand out on one operation right now,
+	* Largest debt one new position can take from this credit manager right now,
 	* and which limit set that number.
 	*
 	* Minimum of:
@@ -290,10 +290,6 @@ var CreditSuite = class extends SDKConstruct {
 	* - the facade's per-account `maxDebt`.
 	* While `maxDebtPerBlockMultiplier` is `0` the facade
 	* takes no new debt at all, so the answer is `0`.
-	*
-	* These are the bounds every debt increase answers to, an existing account's
-	* included, which is what the guards hold a simulation to. Opening a position
-	* answers to two more — see {@link maxStrategyBorrowAmount}.
 	*/
 	maxBorrowAmount() {
 		const { pool } = this.market.pool;
@@ -323,42 +319,6 @@ var CreditSuite = class extends SDKConstruct {
 		};
 	}
 	/**
-	* Largest debt one new position can take from this credit manager right now,
-	* and which limit set that number.
-	*
-	* {@link maxBorrowAmount} held to the two bounds only a position being opened
-	* answers to: the remaining quota of the strategy target collateral, which
-	* the position has to buy to be worth anything, and the facade's `minDebt`,
-	* which a first debt cannot sit under. `amount` is `0` whenever no position
-	* can be opened right now, and `limit` names why.
-	*
-	* An operation on an account that already exists is held to neither: its
-	* quota is weighed against the token its own plan buys, and its debt is
-	* already over the floor, so a top-up smaller than `minDebt` is legal.
-	*/
-	maxStrategyBorrowAmount() {
-		const lends = this.maxBorrowAmount();
-		if (lends.limit === "debtPerBlockLimit") return lends;
-		const collateral = this.strategyTargetCollateral;
-		let value = lends.amount.value;
-		let limit = lends.limit;
-		if (collateral !== void 0) {
-			const quota = this.market.pool.pqk.quotaAvailable(collateral);
-			if (quota < value) {
-				value = quota;
-				limit = "quotaAvailable";
-			}
-		}
-		if (value < this.creditFacade.minDebt) return {
-			amount: this.market.toUnderlyingAmount(0n),
-			limit: "minDebt"
-		};
-		return {
-			amount: this.market.toUnderlyingAmount(value),
-			limit
-		};
-	}
-	/**
 	* The single target collateral of this suite's strategy, or `undefined` when
 	* none can be resolved.
 	*
@@ -415,7 +375,7 @@ var CreditSuite = class extends SDKConstruct {
 	* or `undefined` when credit suite does not offer a strategy opportunity.
 	*/
 	strategyOpportunity() {
-		const maxBorrowAmount = this.maxStrategyBorrowAmount().amount.value;
+		const maxBorrowAmount = this.maxBorrowAmount().amount.value;
 		if (maxBorrowAmount <= MIN_STRATEGY_BORROW_AMOUNT) return;
 		const collateral = this.strategyTargetCollateral;
 		if (!collateral) return;

package/dist/esm/onchain/market/pool/PoolQuotaKeeperV310Contract.js

@@ -1,6 +1,5 @@
 import { iPoolQuotaKeeperV310Abi } from "../../../abi/310/generated.js";
 import { AddressMap } from "../../utils/AddressMap.js";
-import { BigIntMath } from "../../utils/bigint-math.js";
 import { formatBNvalue, percentFmt } from "../../utils/formatter.js";
 import "../../utils/index.js";
 import { BaseContract } from "../../base/BaseContract.js";
@@ -41,12 +40,10 @@ var PoolQuotaKeeperV310Contract = class extends BaseContract {
 	/**
 	* How much more quota the market will take for a token, in the underlying.
 	* `0n` when the market has no quota entry; not the same as {@link hasActiveQuota}.
-	* Never negative: a limit lowered under what is already quoted leaves no
-	* room, not a debt.
 	*/
 	quotaAvailable(token) {
 		const quota = this.quotas.get(token);
-		return quota ? BigIntMath.max(0n, quota.limit - quota.totalQuoted) : 0n;
+		return quota ? quota.limit - quota.totalQuoted : 0n;
 	}
 	/**
 	* Annual quota rate paid on a quoted token, in basis points, or `0` when the

package/dist/esm/rewards/RewardsService.js

@@ -0,0 +1,47 @@
+import { MultichainConstruct } from "../onchain/base/MultichainConstruct.js";
+import "../onchain/index.js";
+import { fetchMerklUserRewards } from "./merkl-api.js";
+import { toMerklRewards } from "./toMerklRewards.js";
+import { toTurtleRewards } from "./toTurtleRewards.js";
+import { fetchTurtleWalletRewards, readTurtleClaimed } from "./turtle-api.js";
+import { getAddress } from "viem";
+//#region src/rewards/RewardsService.ts
+var RewardsService = class extends MultichainConstruct {
+	#keys;
+	constructor(sdk, keys = {}) {
+		super(sdk);
+		this.#keys = keys;
+	}
+	/**
+	* Every claimable reward a wallet holds — Merkl campaigns and the Gearbox
+	* organisation's Turtle streams — across the chains the handle carries.
+	* A chain is `status: "error"` only when every source failed on it; a chain
+	* with nothing to claim is a `"success"` with no rewards.
+	**/
+	async list(wallet, chainIds) {
+		const { merklApiKey, turtleApiKey } = this.#keys;
+		const user = getAddress(wallet);
+		const turtle = turtleApiKey ? fetchTurtleWalletRewards(user, turtleApiKey) : void 0;
+		turtle?.catch(() => {});
+		return this.queryChains({
+			chainIds,
+			label: "list rewards",
+			block: "state",
+			run: async (sdk) => {
+				const sources = [fetchMerklUserRewards({
+					chainId: sdk.chainId,
+					user,
+					apiKey: merklApiKey
+				}).then((response) => toMerklRewards(sdk, response))];
+				if (turtle) sources.push(turtle.then(async (rewards) => toTurtleRewards(sdk, rewards, await readTurtleClaimed(sdk, user, rewards))));
+				const settled = await Promise.allSettled(sources);
+				const failed = settled.flatMap((r) => r.status === "rejected" ? [r.reason] : []);
+				if (failed.length === settled.length) throw failed.length === 1 ? failed[0] : new AggregateError(failed, "no rewards source answered");
+				for (const reason of failed) (sdk.logger ?? this.sdk.logger)?.warn(reason, `rewards source failed on chain ${sdk.chainId}`);
+				return settled.flatMap((r) => r.status === "fulfilled" ? r.value : []);
+			}
+		});
+	}
+};
+//#endregion
+export { RewardsService };

package/dist/esm/rewards/errors.js

@@ -1,7 +1,7 @@
 import { BaseError } from "viem";
 //#region src/rewards/errors.ts
 /**
-* Thrown when none of Merkl's domains answered for a chain.
+* Thrown when Merkl did not answer for a chain.
 *
 * Everything a reader needs is in the message: this error travels to consumers
 * inside a chain's {@link ChainFailed} metadata, where it is typed `unknown`
@@ -10,10 +10,10 @@ import { BaseError } from "viem";
 var MerklRequestFailedError = class extends BaseError {
 	name = "MerklRequestFailedError";
 	chainId;
-	constructor(chainId, path, attempts) {
+	constructor(chainId, path, cause) {
 		super(`Merkl could not be reached for chain ${chainId}.`, {
-			cause: attempts.find(([, c]) => c instanceof Error)?.[1],
-			metaMessages: attempts.map(([domain, cause]) => `${domain}${path} — ${describe(cause)}`)
+			cause: cause instanceof Error ? cause : void 0,
+			metaMessages: [`${path} — ${describe(cause)}`]
 		});
 		this.chainId = chainId;
 	}
@@ -22,5 +22,15 @@ function describe(cause) {
 	if (cause instanceof Error) return cause.name === "TimeoutError" ? "timed out" : cause.message;
 	return String(cause);
 }
+/** Turtle answers for every chain at once, so this names no chain. */
+var TurtleRequestFailedError = class extends BaseError {
+	name = "TurtleRequestFailedError";
+	constructor(path, cause) {
+		super("Turtle could not be reached.", {
+			cause: cause instanceof Error ? cause : void 0,
+			metaMessages: [`${path} — ${describe(cause)}`]
+		});
+	}
+};
 //#endregion
-export { MerklRequestFailedError };
+export { MerklRequestFailedError, TurtleRequestFailedError };

package/dist/esm/rewards/helpers.js

@@ -0,0 +1,83 @@
+import { AddressMap } from "../onchain/utils/AddressMap.js";
+import { toBigInt } from "../onchain/utils/formatter.js";
+import "../onchain/index.js";
+import { formatUnits, isAddress } from "viem";
+//#region src/rewards/helpers.ts
+/**
+* The pool a source names, and its share token. A v3.1 pool is its own
+* ERC-4626 share token, so its address is the only token a campaign can name;
+* the `AddressMap` owns the casing a source writes it in.
+*/
+function resolvePool(sdk) {
+	const pools = AddressMap.fromMappedArray(sdk.marketRegister.pools.map(({ pool }) => pool.address), (address) => address);
+	return (address) => {
+		if (!address || !isAddress(address, { strict: false })) return void 0;
+		const pool = pools.get(address);
+		const poolToken = pool && sdk.tokensMeta.getToken(pool);
+		return pool && poolToken ? {
+			pool,
+			poolToken
+		} : void 0;
+	};
+}
+/** Sources send amounts as free-form strings, which `toBigInt` throws on. */
+function parseAmount(value) {
+	if (value === void 0) return void 0;
+	try {
+		return toBigInt(value || 0);
+	} catch {
+		return;
+	}
+}
+/** What is left of `total` after `claimed`, when anything is. */
+function remaining(total, claimed) {
+	if (total === void 0 || claimed === void 0) return void 0;
+	return total > claimed ? total - claimed : void 0;
+}
+/**
+* An incentive token is rarely protocol collateral, so the registry usually
+* has no entry for it — and both sources always name it.
+*/
+function toRewardToken(sdk, address, named) {
+	return sdk.tokensMeta.getToken(address) ?? {
+		chainId: sdk.chainId,
+		address,
+		symbol: named.symbol,
+		name: named.name ?? named.symbol,
+		decimals: named.decimals || 18
+	};
+}
+/** A missing or unparsable price is `null`. */
+function toPricedAmount(token, value, price) {
+	const usd = Number(price ?? NaN);
+	return {
+		token,
+		value,
+		valueUsd: Number.isFinite(usd) ? Number(formatUnits(value, token.decimals)) * usd : null
+	};
+}
+/**
+* One reward per pool and incentive token, at the last part's price. Amounts
+* are summed raw and priced once at the end — pricing each part and adding the results would round
+* every one of them.
+*/
+function mergeRewards(sdk, source, parts) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const part of parts) {
+		const key = `${part.pool}_${part.token.address}`;
+		const seen = merged.get(key);
+		merged.set(key, seen ? {
+			...part,
+			value: seen.value + part.value
+		} : part);
+	}
+	return [...merged.values()].map(({ pool, poolToken, token, value, price }) => ({
+		source,
+		chainId: sdk.chainId,
+		pool,
+		poolToken,
+		amount: toPricedAmount(token, value, price)
+	}));
+}
+//#endregion
+export { mergeRewards, parseAmount, remaining, resolvePool, toRewardToken };

package/dist/esm/rewards/index.js

@@ -1,4 +1,3 @@
-import { MerklRequestFailedError } from "./errors.js";
-import { toMerklRewards } from "./toMerklRewards.js";
-import { getMerklRewardsMultichain } from "./multichain.js";
-export { MerklRequestFailedError, getMerklRewardsMultichain, toMerklRewards };
+import { MerklRequestFailedError, TurtleRequestFailedError } from "./errors.js";
+import { RewardsService } from "./RewardsService.js";
+export { MerklRequestFailedError, RewardsService, TurtleRequestFailedError };

package/dist/esm/rewards/merkl-api.js

@@ -1,42 +1,32 @@
 import { MerklRequestFailedError } from "./errors.js";
 //#region src/rewards/merkl-api.ts
-/**
-* Merkl's own host and the Angle mirror, tried in this order.
-*/
-const MERKL_DOMAINS = ["https://api.merkl.xyz", "https://api-merkl.angle.money"];
+const MERKL_API_URL = "https://api.merkl.xyz";
 const MERKL_API_KEY_HEADER = "X-API-Key";
 /**
-* Per-attempt budget. Merkl has no timeout of its own, and a hung connection
-* would otherwise stall its leg of a fan-out for as long as the socket lives.
+* Merkl has no timeout of its own, and a hung connection would otherwise stall
+* its leg of a fan-out for as long as the socket lives.
 */
-const ATTEMPT_TIMEOUT = 1e4;
+const TIMEOUT = 1e4;
 /**
 * The wallet's raw Merkl rewards on one chain.
 *
-* Rejects with {@link MerklRequestFailedError} when neither domain answers, so
-* a caller can tell an unreachable Merkl from a wallet with nothing to claim.
-* A non-2xx counts as no answer and moves to the next domain: it carries no
-* rewards either way, and treating it as success would report emptiness that
-* was never established.
+* Rejects with {@link MerklRequestFailedError} when Merkl does not answer, so a
+* caller can tell an unreachable Merkl from a wallet with nothing to claim. A
+* non-2xx counts as no answer: it carries no rewards either way, and treating
+* it as success would report emptiness that was never established.
 */
 async function fetchMerklUserRewards({ chainId, user, apiKey }) {
 	const path = `/v4/users/${user}/rewards?chainId=${chainId}`;
-	const headers = apiKey ? { [MERKL_API_KEY_HEADER]: apiKey } : void 0;
-	const attempts = [];
-	for (const domain of MERKL_DOMAINS) try {
-		const response = await fetch(`${domain}${path}`, {
-			headers,
-			signal: AbortSignal.timeout(ATTEMPT_TIMEOUT)
+	try {
+		const response = await fetch(`${MERKL_API_URL}${path}`, {
+			headers: apiKey ? { [MERKL_API_KEY_HEADER]: apiKey } : void 0,
+			signal: AbortSignal.timeout(TIMEOUT)
 		});
-		if (!response.ok) {
-			attempts.push([domain, /* @__PURE__ */ new Error(`answered ${response.status}`)]);
-			continue;
-		}
+		if (!response.ok) throw new Error(`answered ${response.status}`);
 		return await response.json();
 	} catch (error) {
-		attempts.push([domain, error]);
+		throw new MerklRequestFailedError(chainId, path, error);
 	}
-	throw new MerklRequestFailedError(chainId, path, attempts);
 }
 //#endregion
-export { MERKL_API_KEY_HEADER, MERKL_DOMAINS, fetchMerklUserRewards };
+export { MERKL_API_KEY_HEADER, fetchMerklUserRewards };

package/dist/esm/rewards/toMerklRewards.js

@@ -1,84 +1,29 @@
-import { AddressMap } from "../onchain/utils/AddressMap.js";
-import { BigIntMath } from "../onchain/utils/bigint-math.js";
-import { toBigInt } from "../onchain/utils/formatter.js";
-import "../onchain/index.js";
-import { formatUnits, getAddress, isAddress } from "viem";
+import { mergeRewards, parseAmount, remaining, resolvePool, toRewardToken } from "./helpers.js";
+import { getAddress, isAddress } from "viem";
 //#region src/rewards/toMerklRewards.ts
 /**
-* Merkl's answer for one chain, turned into rows of the read model.
+* Merkl's answer for one chain, one reward per pool and incentive token.
+* A breakdown Merkl cannot be read from is skipped rather than thrown on: it
+* must not sink the chain, which the caller would then be told is unreachable.
 */
 function toMerklRewards(sdk, response) {
-	const poolByItsToken = AddressMap.fromMappedArray(sdk.marketRegister.pools.map(({ pool }) => pool.address), (address) => address);
-	const claimable = /* @__PURE__ */ new Map();
-	for (const chainRewards of response) for (const reward of chainRewards.rewards) {
-		if (!isAddress(reward.token.address, { strict: false })) continue;
-		const rewardTokenAddress = getAddress(reward.token.address);
-		for (const reason of reward.breakdowns) {
-			const poolTokenAddress = (reason.reason || "").split("_").find((part) => part.startsWith("0x")) ?? "";
-			if (!isAddress(poolTokenAddress, { strict: false })) continue;
-			const pool = poolByItsToken.get(poolTokenAddress);
-			if (!pool) continue;
-			const amounts = toAmounts(reason);
-			if (!amounts) continue;
-			const amount = BigIntMath.max(amounts.total - amounts.claimed, 0n);
-			if (amount === 0n) continue;
-			const key = `${pool}_${rewardTokenAddress}`;
-			const seen = claimable.get(key);
-			if (seen) {
-				seen.value += amount;
-				continue;
-			}
-			const poolToken = sdk.tokensMeta.getToken(pool);
-			if (!poolToken) continue;
-			claimable.set(key, {
-				chainId: sdk.chainId,
-				pool,
-				poolToken,
-				token: toRewardToken(sdk, rewardTokenAddress, reward.token),
-				value: amount,
-				price: reward.token.price
-			});
-		}
-	}
-	return [...claimable.values()].map(toReward);
-}
-/**
-* `toBigInt` throws on anything `BigInt()` cannot parse, and Merkl's amounts
-* are free-form strings.
-*/
-function toAmounts(reason) {
-	try {
-		return {
-			total: toBigInt(reason.amount || 0),
-			claimed: toBigInt(reason.claimed || 0)
-		};
-	} catch {
-		return;
-	}
-}
-function toReward({ price, token, value, ...rest }) {
-	return {
-		...rest,
-		amount: {
-			token,
-			value,
-			valueUsd: price === void 0 ? null : Number(formatUnits(value, token.decimals)) * price
-		}
-	};
-}
-/**
-* A campaign's incentive token is not protocol collateral, so the registry
-* usually has no entry for it — and Merkl always names it. The one place the
-* two sources are reconciled.
-*/
-function toRewardToken(sdk, address, merkl) {
-	return sdk.tokensMeta.getToken(address) ?? {
-		chainId: sdk.chainId,
-		address,
-		symbol: merkl.symbol,
-		name: merkl.symbol,
-		decimals: merkl.decimals || 18
-	};
+	const poolOf = resolvePool(sdk);
+	const parts = response.flatMap(({ rewards }) => rewards).flatMap(({ token, breakdowns }) => {
+		if (!isAddress(token.address, { strict: false })) return [];
+		const rewardToken = toRewardToken(sdk, getAddress(token.address), token);
+		return breakdowns.flatMap(({ reason, amount, claimed }) => {
+			const pool = poolOf(reason?.split("_").find((p) => p.startsWith("0x")));
+			const value = remaining(parseAmount(amount), parseAmount(claimed));
+			if (!pool || !value) return [];
+			return [{
+				...pool,
+				token: rewardToken,
+				value,
+				price: token.price
+			}];
+		});
+	});
+	return mergeRewards(sdk, "merkl", parts);
 }
 //#endregion
 export { toMerklRewards };

package/dist/esm/rewards/toTurtleRewards.js

@@ -0,0 +1,60 @@
+import { mergeRewards, parseAmount, remaining, resolvePool, toRewardToken } from "./helpers.js";
+import { formatUnits, getAddress, isAddress } from "viem";
+//#region src/rewards/toTurtleRewards.ts
+/**
+* The streams targeting a pool on the SDK's chain, merged per pool and
+* incentive. A token reward is what is committed and not yet claimed.
+*/
+function toTurtleRewards(sdk, { streams, proofs }, claimed) {
+	const poolOf = resolvePool(sdk);
+	const committed = new Map(proofs.map((p) => [p.streamId, p.amount]));
+	const targeted = streams.flatMap((stream) => {
+		const target = stream.stream.customArgs.targetToken;
+		if (Number(target?.chain.chainId) !== sdk.chainId) return [];
+		const pool = poolOf(target?.address);
+		return pool ? [{
+			stream,
+			...pool
+		}] : [];
+	});
+	const tokens = targeted.flatMap(({ stream, pool, poolToken }) => {
+		const { point, rewardToken, lastSnapshot } = stream.stream;
+		if (point || !rewardToken || !isAddress(rewardToken.address, { strict: false })) return [];
+		const value = remaining(parseAmount(committed.get(stream.streamId)), claimed.get(stream.streamId));
+		if (!value) return [];
+		return [{
+			pool,
+			poolToken,
+			token: toRewardToken(sdk, getAddress(rewardToken.address), rewardToken),
+			value,
+			price: lastSnapshot?.rewardTokenPrice
+		}];
+	});
+	return [...mergeRewards(sdk, "turtle", tokens), ...toPoints(sdk, targeted)];
+}
+/** Points accrue per snapshot; the last one holds the running total. */
+function toPoints(sdk, targeted) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const { stream, pool, poolToken } of targeted) {
+		const { point } = stream.stream;
+		const raw = parseAmount(stream.snapshots.at(-1)?.rewardsAccumulated);
+		if (!point || !raw) continue;
+		const key = `${pool}_${point.id}`;
+		const value = (merged.get(key)?.points.value ?? 0) + Number(formatUnits(raw, point.decimals));
+		merged.set(key, {
+			source: "turtle",
+			chainId: sdk.chainId,
+			pool,
+			poolToken,
+			points: {
+				id: point.id,
+				name: point.name,
+				multiplier: null,
+				value
+			}
+		});
+	}
+	return [...merged.values()];
+}
+//#endregion
+export { toTurtleRewards };

package/dist/esm/rewards/turtle-api.js

@@ -0,0 +1,64 @@
+import { TurtleRequestFailedError } from "./errors.js";
+//#region src/rewards/turtle-api.ts
+const TURTLE_API_URL = "https://earn.turtle.xyz";
+const GEARBOX_ORG_ID = "d171ba3d-ff89-4e6c-8f13-d94840b06edd";
+const TIMEOUT = 1e4;
+const turtleStreamAbi = [{
+	type: "function",
+	name: "getClaimedRewards",
+	stateMutability: "view",
+	inputs: [{
+		name: "user",
+		type: "address"
+	}],
+	outputs: [{
+		name: "",
+		type: "uint256"
+	}]
+}];
+async function fetchTurtleWalletRewards(user, apiKey) {
+	const { streams: all } = await get(`/v2/streams/wallets/${user}`, apiKey);
+	const streams = all.filter((s) => s.stream.orgId === GEARBOX_ORG_ID);
+	const tokenStreamIds = streams.filter((s) => s.stream.rewardToken && s.stream.contractAddress).map((s) => s.streamId);
+	if (tokenStreamIds.length === 0) return {
+		streams,
+		proofs: []
+	};
+	const query = new URLSearchParams({ wallet: user });
+	for (const id of tokenStreamIds) query.append("streamIds", id);
+	const { proofs } = await get(`/v2/streams/merkle_proofs?${query}`, apiKey);
+	return {
+		streams,
+		proofs
+	};
+}
+async function get(path, apiKey) {
+	try {
+		const response = await fetch(`${TURTLE_API_URL}${path}`, {
+			headers: { "X-API-Key": apiKey },
+			signal: AbortSignal.timeout(TIMEOUT)
+		});
+		if (!response.ok) throw new Error(`answered ${response.status}`);
+		return await response.json();
+	} catch (error) {
+		throw new TurtleRequestFailedError(path, error);
+	}
+}
+/** What each of the wallet's streams on the chain has paid out, at the latest block. */
+async function readTurtleClaimed(sdk, user, { proofs }) {
+	const onChain = proofs.filter((p) => p.chainId === sdk.chainId);
+	if (onChain.length === 0) return /* @__PURE__ */ new Map();
+	const claimed = await sdk.client.multicall({
+		contracts: onChain.map((p) => ({
+			address: p.contractAddress,
+			abi: turtleStreamAbi,
+			functionName: "getClaimedRewards",
+			args: [user]
+		})),
+		allowFailure: false,
+		blockTag: "latest"
+	});
+	return new Map(onChain.map((p, i) => [p.streamId, claimed[i]]));
+}
+//#endregion
+export { fetchTurtleWalletRewards, readTurtleClaimed, turtleStreamAbi };

package/dist/esm/rewards/types.js

@@ -0,0 +1 @@
+export {};

package/dist/types/model/errors/operation-errors.d.ts

@@ -11,16 +11,11 @@ import { Address } from "viem";
  * - `poolAvailableLiquidity` — the pool's available liquidity
  * - `managerDebtAvailable` — this credit manager's remaining debt allowance
  * - `maxDebt` — the facade's per-account `debtLimits.maxDebt`
- * - `quotaAvailable` — remaining quota the market takes for the suite's
- *   strategy target collateral (`limit - totalQuoted`, floored at 0); only an
- *   account being opened is held to it
- * - `minDebt` — every other limit left less than the facade's `minDebt`, so
- *   no account can be opened; the amount is 0
  * - `debtPerBlockLimit` — facade takes no new debt this block; in practice
  *   `maxDebtPerBlockMultiplier == 0` after a with-loss liquidation
  * - `poolDebtLimit` — pool-wide debt cap; used on account-opening only
  **/
-type BorrowLimitCause = "poolAvailableLiquidity" | "managerDebtAvailable" | "maxDebt" | "quotaAvailable" | "minDebt" | "debtPerBlockLimit" | "poolDebtLimit";
+type BorrowLimitCause = "poolAvailableLiquidity" | "managerDebtAvailable" | "maxDebt" | "debtPerBlockLimit" | "poolDebtLimit";
 /**
  * The credit manager is paused and takes no multicall at all.
  **/