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

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

@@ -21,18 +21,16 @@ const require_onchain_accounts_intents_collateral_valuation = require("./collate
 * 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.
@@ -83,7 +81,7 @@ function maxBorrow(props) {
 	const weighted = valuation.checkedUsd(holding) * valuation.lt(collateralToken);
 	const backed = quotas.some((q) => require_onchain_accounts_intents_utils_common.eq(q.token, collateralToken)) ? require_onchain_utils_bigint_math.BigIntMath.min(valuation.quotaValue(holding), weighted) : weighted;
 	if (backed <= 0n) return 0n;
-	const ceiling = require_onchain_utils_bigint_math.BigIntMath.min(priceOracle.safeConvertFromUSD(underlying, backed / targetHF).value, suite.maxStrategyBorrowAmount().amount.value);
+	const ceiling = require_onchain_utils_bigint_math.BigIntMath.min(priceOracle.safeConvertFromUSD(underlying, backed / targetHF).value, suite.maxBorrowAmount().amount.value);
 	const unwrapsPayout = !!rwaAsset && require_onchain_accounts_intents_utils_common.eq(borrowToken, rwaAsset);
 	return require_onchain_accounts_intents_utils_common.eq(borrowToken, underlying) ? ceiling : unwrapsPayout ? require_onchain_accounts_intents_utils_common.toTargetDecimals(ceiling, underlying, borrowToken, sdk) : priceOracle.safeConvert(underlying, borrowToken, ceiling).value;
 }

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

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

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

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

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

@@ -19,7 +19,7 @@ let viem = require("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;
@@ -282,7 +282,7 @@ var CreditSuite = class extends require_onchain_base_SDKConstruct.SDKConstruct {
 		return this.forbiddenTokens.some((f) => (0, viem.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:
@@ -291,10 +291,6 @@ var CreditSuite = class extends require_onchain_base_SDKConstruct.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;
@@ -324,42 +320,6 @@ var CreditSuite = class extends require_onchain_base_SDKConstruct.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.
 	*
@@ -416,7 +376,7 @@ var CreditSuite = class extends require_onchain_base_SDKConstruct.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/cjs/onchain/market/pool/PoolQuotaKeeperV310Contract.js

@@ -1,7 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_abi_310_generated = require("../../../abi/310/generated.js");
 const require_onchain_utils_AddressMap = require("../../utils/AddressMap.js");
-const require_onchain_utils_bigint_math = require("../../utils/bigint-math.js");
 const require_onchain_utils_formatter = require("../../utils/formatter.js");
 require("../../utils/index.js");
 const require_onchain_base_BaseContract = require("../../base/BaseContract.js");
@@ -42,12 +41,10 @@ var PoolQuotaKeeperV310Contract = class extends require_onchain_base_BaseContrac
 	/**
 	* 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 ? require_onchain_utils_bigint_math.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/cjs/rewards/RewardsService.js

@@ -0,0 +1,48 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_base_MultichainConstruct = require("../onchain/base/MultichainConstruct.js");
+require("../onchain/index.js");
+const require_rewards_merkl_api = require("./merkl-api.js");
+const require_rewards_toMerklRewards = require("./toMerklRewards.js");
+const require_rewards_toTurtleRewards = require("./toTurtleRewards.js");
+const require_rewards_turtle_api = require("./turtle-api.js");
+let viem = require("viem");
+//#region src/rewards/RewardsService.ts
+var RewardsService = class extends require_onchain_base_MultichainConstruct.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 = (0, viem.getAddress)(wallet);
+		const turtle = turtleApiKey ? require_rewards_turtle_api.fetchTurtleWalletRewards(user, turtleApiKey) : void 0;
+		turtle?.catch(() => {});
+		return this.queryChains({
+			chainIds,
+			label: "list rewards",
+			block: "state",
+			run: async (sdk) => {
+				const sources = [require_rewards_merkl_api.fetchMerklUserRewards({
+					chainId: sdk.chainId,
+					user,
+					apiKey: merklApiKey
+				}).then((response) => require_rewards_toMerklRewards.toMerklRewards(sdk, response))];
+				if (turtle) sources.push(turtle.then(async (rewards) => require_rewards_toTurtleRewards.toTurtleRewards(sdk, rewards, await require_rewards_turtle_api.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
+exports.RewardsService = RewardsService;

package/dist/cjs/rewards/errors.js

@@ -2,7 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let viem = require("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`
@@ -11,10 +11,10 @@ let viem = require("viem");
 var MerklRequestFailedError = class extends viem.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;
 	}
@@ -23,5 +23,16 @@ 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 viem.BaseError {
+	name = "TurtleRequestFailedError";
+	constructor(path, cause) {
+		super("Turtle could not be reached.", {
+			cause: cause instanceof Error ? cause : void 0,
+			metaMessages: [`${path} — ${describe(cause)}`]
+		});
+	}
+};
 //#endregion
 exports.MerklRequestFailedError = MerklRequestFailedError;
+exports.TurtleRequestFailedError = TurtleRequestFailedError;

package/dist/cjs/rewards/helpers.js

@@ -0,0 +1,88 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_utils_AddressMap = require("../onchain/utils/AddressMap.js");
+const require_onchain_utils_formatter = require("../onchain/utils/formatter.js");
+require("../onchain/index.js");
+let viem = require("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 = require_onchain_utils_AddressMap.AddressMap.fromMappedArray(sdk.marketRegister.pools.map(({ pool }) => pool.address), (address) => address);
+	return (address) => {
+		if (!address || !(0, viem.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 require_onchain_utils_formatter.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((0, viem.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
+exports.mergeRewards = mergeRewards;
+exports.parseAmount = parseAmount;
+exports.remaining = remaining;
+exports.resolvePool = resolvePool;
+exports.toRewardToken = toRewardToken;

package/dist/cjs/rewards/index.js

@@ -1,7 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rewards_errors = require("./errors.js");
-const require_rewards_toMerklRewards = require("./toMerklRewards.js");
-const require_rewards_multichain = require("./multichain.js");
+const require_rewards_RewardsService = require("./RewardsService.js");
 exports.MerklRequestFailedError = require_rewards_errors.MerklRequestFailedError;
-exports.getMerklRewardsMultichain = require_rewards_multichain.getMerklRewardsMultichain;
-exports.toMerklRewards = require_rewards_toMerklRewards.toMerklRewards;
+exports.RewardsService = require_rewards_RewardsService.RewardsService;
+exports.TurtleRequestFailedError = require_rewards_errors.TurtleRequestFailedError;

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

@@ -1,45 +1,34 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rewards_errors = require("./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 require_rewards_errors.MerklRequestFailedError(chainId, path, error);
 	}
-	throw new require_rewards_errors.MerklRequestFailedError(chainId, path, attempts);
 }
 //#endregion
 exports.MERKL_API_KEY_HEADER = MERKL_API_KEY_HEADER;
-exports.MERKL_DOMAINS = MERKL_DOMAINS;
 exports.fetchMerklUserRewards = fetchMerklUserRewards;

package/dist/cjs/rewards/toMerklRewards.js

@@ -1,85 +1,30 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_onchain_utils_AddressMap = require("../onchain/utils/AddressMap.js");
-const require_onchain_utils_bigint_math = require("../onchain/utils/bigint-math.js");
-const require_onchain_utils_formatter = require("../onchain/utils/formatter.js");
-require("../onchain/index.js");
+const require_rewards_helpers = require("./helpers.js");
 let viem = require("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 = require_onchain_utils_AddressMap.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 (!(0, viem.isAddress)(reward.token.address, { strict: false })) continue;
-		const rewardTokenAddress = (0, viem.getAddress)(reward.token.address);
-		for (const reason of reward.breakdowns) {
-			const poolTokenAddress = (reason.reason || "").split("_").find((part) => part.startsWith("0x")) ?? "";
-			if (!(0, viem.isAddress)(poolTokenAddress, { strict: false })) continue;
-			const pool = poolByItsToken.get(poolTokenAddress);
-			if (!pool) continue;
-			const amounts = toAmounts(reason);
-			if (!amounts) continue;
-			const amount = require_onchain_utils_bigint_math.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: require_onchain_utils_formatter.toBigInt(reason.amount || 0),
-			claimed: require_onchain_utils_formatter.toBigInt(reason.claimed || 0)
-		};
-	} catch {
-		return;
-	}
-}
-function toReward({ price, token, value, ...rest }) {
-	return {
-		...rest,
-		amount: {
-			token,
-			value,
-			valueUsd: price === void 0 ? null : Number((0, viem.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 = require_rewards_helpers.resolvePool(sdk);
+	const parts = response.flatMap(({ rewards }) => rewards).flatMap(({ token, breakdowns }) => {
+		if (!(0, viem.isAddress)(token.address, { strict: false })) return [];
+		const rewardToken = require_rewards_helpers.toRewardToken(sdk, (0, viem.getAddress)(token.address), token);
+		return breakdowns.flatMap(({ reason, amount, claimed }) => {
+			const pool = poolOf(reason?.split("_").find((p) => p.startsWith("0x")));
+			const value = require_rewards_helpers.remaining(require_rewards_helpers.parseAmount(amount), require_rewards_helpers.parseAmount(claimed));
+			if (!pool || !value) return [];
+			return [{
+				...pool,
+				token: rewardToken,
+				value,
+				price: token.price
+			}];
+		});
+	});
+	return require_rewards_helpers.mergeRewards(sdk, "merkl", parts);
 }
 //#endregion
 exports.toMerklRewards = toMerklRewards;

package/dist/cjs/rewards/toTurtleRewards.js

@@ -0,0 +1,61 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rewards_helpers = require("./helpers.js");
+let viem = require("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 = require_rewards_helpers.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 || !(0, viem.isAddress)(rewardToken.address, { strict: false })) return [];
+		const value = require_rewards_helpers.remaining(require_rewards_helpers.parseAmount(committed.get(stream.streamId)), claimed.get(stream.streamId));
+		if (!value) return [];
+		return [{
+			pool,
+			poolToken,
+			token: require_rewards_helpers.toRewardToken(sdk, (0, viem.getAddress)(rewardToken.address), rewardToken),
+			value,
+			price: lastSnapshot?.rewardTokenPrice
+		}];
+	});
+	return [...require_rewards_helpers.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 = require_rewards_helpers.parseAmount(stream.snapshots.at(-1)?.rewardsAccumulated);
+		if (!point || !raw) continue;
+		const key = `${pool}_${point.id}`;
+		const value = (merged.get(key)?.points.value ?? 0) + Number((0, viem.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
+exports.toTurtleRewards = toTurtleRewards;

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

@@ -0,0 +1,67 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rewards_errors = require("./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 require_rewards_errors.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
+exports.fetchTurtleWalletRewards = fetchTurtleWalletRewards;
+exports.readTurtleClaimed = readTurtleClaimed;
+exports.turtleStreamAbi = turtleStreamAbi;

package/dist/cjs/rewards/types.js

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