@gearbox-protocol/sdk 17.2.0 → 17.2.1

package/dist/cjs/rewards/{multichain.js → RewardsService.js}

@@ -6,9 +6,21 @@ 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/multichain.ts
-var RewardsFanOut = class extends require_onchain_base_MultichainConstruct.MultichainConstruct {
-	async list({ wallet, chainIds, merklApiKey, turtleApiKey }) {
+//#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(() => {});
@@ -16,13 +28,13 @@ var RewardsFanOut = class extends require_onchain_base_MultichainConstruct.Multi
 			chainIds,
 			label: "list rewards",
 			block: "state",
-			run: async (sdk, block) => {
+			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 readClaimed(sdk, user, rewards, block.blockNumber))));
+				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");
@@ -32,29 +44,5 @@ var RewardsFanOut = class extends require_onchain_base_MultichainConstruct.Multi
 		});
 	}
 };
-async function readClaimed(sdk, user, { proofs }, blockNumber) {
-	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: require_rewards_turtle_api.turtleStreamAbi,
-			functionName: "getClaimedRewards",
-			args: [user]
-		})),
-		allowFailure: false,
-		blockNumber
-	});
-	return new Map(onChain.map((p, i) => [p.streamId, claimed[i]]));
-}
-/**
-* 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 rows.
-**/
-async function getRewardsMultichain({ sdk, ...props }) {
-	return new RewardsFanOut(sdk).list(props);
-}
 //#endregion
-exports.getRewardsMultichain = getRewardsMultichain;
+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;
 	}

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,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rewards_errors = require("./errors.js");
-const require_rewards_multichain = require("./multichain.js");
+const require_rewards_RewardsService = require("./RewardsService.js");
 exports.MerklRequestFailedError = require_rewards_errors.MerklRequestFailedError;
+exports.RewardsService = require_rewards_RewardsService.RewardsService;
 exports.TurtleRequestFailedError = require_rewards_errors.TurtleRequestFailedError;
-exports.getRewardsMultichain = require_rewards_multichain.getRewardsMultichain;

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,86 +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,
-		source: "merkl",
-		amount: {
-			token,
-			value,
-			valueUsd: price === void 0 ? null : Number((0, viem.formatUnits)(value, token.decimals)) * price
-		}
-	};
-}
-/**
-* 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
-	};
+	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;
-exports.toRewardToken = toRewardToken;

package/dist/cjs/rewards/toTurtleRewards.js

@@ -1,77 +1,61 @@
 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_toMerklRewards = require("./toMerklRewards.js");
+const require_rewards_helpers = require("./helpers.js");
 let viem = require("viem");
 //#region src/rewards/toTurtleRewards.ts
 /**
-* Rows for the streams targeting a pool on the SDK's chain, merged per pool
-* and incentive. A token row is what is committed and not yet claimed.
+* 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 pools = require_onchain_utils_AddressMap.AddressMap.fromMappedArray(sdk.marketRegister.pools.map(({ pool }) => pool.address), (address) => address);
-	const proofByStream = new Map(proofs.map((p) => [p.streamId, p]));
-	const rows = /* @__PURE__ */ new Map();
-	for (const { streamId, snapshots, stream } of streams) {
-		const target = stream.customArgs.targetToken;
-		if (!target || Number(target.chain.chainId) !== sdk.chainId) continue;
-		if (!(0, viem.isAddress)(target.address, { strict: false })) continue;
-		const pool = pools.get(target.address);
-		const poolToken = pool && sdk.tokensMeta.getToken(pool);
-		if (!pool || !poolToken) continue;
-		const base = {
+	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
-		};
-		const { point, rewardToken } = stream;
-		if (point) {
-			const value = parse(snapshots.at(-1)?.rewardsAccumulated);
-			if (!value) continue;
-			const key = `${pool}_${point.id}`;
-			const seen = rows.get(key);
-			rows.set(key, {
-				...base,
-				points: {
-					id: point.id,
-					name: point.name,
-					multiplier: null,
-					value: (seen?.points.value ?? 0) + Number((0, viem.formatUnits)(value, point.decimals))
-				}
-			});
-			continue;
-		}
-		if (!rewardToken || !(0, viem.isAddress)(rewardToken.address, { strict: false })) continue;
-		const committed = parse(proofByStream.get(streamId)?.amount);
-		const done = claimed.get(streamId);
-		if (committed === void 0 || done === void 0) continue;
-		const value = require_onchain_utils_bigint_math.BigIntMath.max(committed - done, 0n);
-		if (value === 0n) continue;
-		const token = require_rewards_toMerklRewards.toRewardToken(sdk, (0, viem.getAddress)(rewardToken.address), rewardToken);
-		const key = `${pool}_${token.address}`;
-		const total = (rows.get(key)?.amount.value ?? 0n) + value;
-		const price = Number(stream.lastSnapshot?.rewardTokenPrice ?? NaN);
-		rows.set(key, {
-			...base,
-			amount: {
-				token,
-				value: total,
-				valueUsd: Number.isFinite(price) ? Number((0, viem.formatUnits)(total, token.decimals)) * price : null
+			poolToken,
+			points: {
+				id: point.id,
+				name: point.name,
+				multiplier: null,
+				value
 			}
 		});
 	}
-	return [...rows.values()];
-}
-function parse(amount) {
-	if (amount === void 0) return void 0;
-	try {
-		return require_onchain_utils_formatter.toBigInt(amount);
-	} catch {
-		return;
-	}
+	return [...merged.values()];
 }
 //#endregion
 exports.toTurtleRewards = toTurtleRewards;

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

@@ -45,6 +45,23 @@ async function get(path, apiKey) {
 		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" });

package/dist/esm/rewards/{multichain.js → RewardsService.js}

@@ -3,11 +3,23 @@ import "../onchain/index.js";
 import { fetchMerklUserRewards } from "./merkl-api.js";
 import { toMerklRewards } from "./toMerklRewards.js";
 import { toTurtleRewards } from "./toTurtleRewards.js";
-import { fetchTurtleWalletRewards, turtleStreamAbi } from "./turtle-api.js";
+import { fetchTurtleWalletRewards, readTurtleClaimed } from "./turtle-api.js";
 import { getAddress } from "viem";
-//#region src/rewards/multichain.ts
-var RewardsFanOut = class extends MultichainConstruct {
-	async list({ wallet, chainIds, merklApiKey, turtleApiKey }) {
+//#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(() => {});
@@ -15,13 +27,13 @@ var RewardsFanOut = class extends MultichainConstruct {
 			chainIds,
 			label: "list rewards",
 			block: "state",
-			run: async (sdk, block) => {
+			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 readClaimed(sdk, user, rewards, block.blockNumber))));
+				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");
@@ -31,29 +43,5 @@ var RewardsFanOut = class extends MultichainConstruct {
 		});
 	}
 };
-async function readClaimed(sdk, user, { proofs }, blockNumber) {
-	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,
-		blockNumber
-	});
-	return new Map(onChain.map((p, i) => [p.streamId, claimed[i]]));
-}
-/**
-* 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 rows.
-**/
-async function getRewardsMultichain({ sdk, ...props }) {
-	return new RewardsFanOut(sdk).list(props);
-}
 //#endregion
-export { getRewardsMultichain };
+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;
 	}