@gearbox-protocol/sdk 17.2.0 → 17.2.1

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,3 +1,3 @@
 import { MerklRequestFailedError, TurtleRequestFailedError } from "./errors.js";
-import { getRewardsMultichain } from "./multichain.js";
-export { MerklRequestFailedError, TurtleRequestFailedError, getRewardsMultichain };
+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,
-		source: "merkl",
-		amount: {
-			token,
-			value,
-			valueUsd: price === void 0 ? null : Number(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 = 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, toRewardToken };
+export { toMerklRewards };

package/dist/esm/rewards/toTurtleRewards.js

@@ -1,76 +1,60 @@
-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 { toRewardToken } from "./toMerklRewards.js";
+import { mergeRewards, parseAmount, remaining, resolvePool, toRewardToken } from "./helpers.js";
 import { formatUnits, getAddress, isAddress } from "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 = 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 (!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 = 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
-		};
-		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(formatUnits(value, point.decimals))
-				}
-			});
-			continue;
-		}
-		if (!rewardToken || !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 = BigIntMath.max(committed - done, 0n);
-		if (value === 0n) continue;
-		const token = toRewardToken(sdk, 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(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 toBigInt(amount);
-	} catch {
-		return;
-	}
+	return [...merged.values()];
 }
 //#endregion
 export { toTurtleRewards };

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

@@ -44,5 +44,21 @@ async function get(path, apiKey) {
 		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, turtleStreamAbi };
+export { fetchTurtleWalletRewards, readTurtleClaimed, turtleStreamAbi };

package/dist/esm/rewards/types.js

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

package/dist/types/rewards/RewardsService.d.ts

@@ -0,0 +1,29 @@
+import { ChainId } from "../model/primitives.js";
+import { DataResponse } from "../model/response.js";
+import "../model/index.js";
+import { PluginsMap } from "../onchain/plugins/types.js";
+import { MultichainSDK } from "../onchain/MultichainSDK.js";
+import { MultichainConstruct } from "../onchain/base/MultichainConstruct.js";
+import "../onchain/index.js";
+import { Reward } from "./types.js";
+import { Address } from "viem";
+//#region src/rewards/RewardsService.d.ts
+interface RewardsServiceKeys {
+  /** Raises Merkl's rate limit; the keyless path answers too. */
+  merklApiKey?: string;
+  /** Turtle is skipped without one: its API answers no keyless request. */
+  turtleApiKey?: string;
+}
+declare class RewardsService<const Plugins extends PluginsMap = {}> extends MultichainConstruct<Plugins> {
+  #private;
+  constructor(sdk: MultichainSDK<Plugins>, keys?: RewardsServiceKeys);
+  /**
+   * 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.
+   **/
+  list(wallet: Address, chainIds?: ChainId[]): Promise<DataResponse<Reward[]>>;
+}
+//#endregion
+export { RewardsService };

package/dist/types/rewards/errors.d.ts

@@ -3,7 +3,7 @@ import "../model/index.js";
 import { BaseError } from "viem";
 //#region src/rewards/errors.d.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`
@@ -12,7 +12,7 @@ import { BaseError } from "viem";
 declare class MerklRequestFailedError extends BaseError {
   name: string;
   readonly chainId: ChainId;
-  constructor(chainId: ChainId, path: string, attempts: ReadonlyArray<[domain: string, cause: unknown]>);
+  constructor(chainId: ChainId, path: string, cause: unknown);
 }
 /** Turtle answers for every chain at once, so this names no chain. */
 declare class TurtleRequestFailedError extends BaseError {

package/dist/types/rewards/helpers.d.ts

@@ -0,0 +1,44 @@
+import { Token } from "../model/primitives.js";
+import "../model/index.js";
+import { MerklReward, RewardsSdk } from "./types.js";
+import { Address } from "viem";
+//#region src/rewards/helpers.d.ts
+/** A claimable amount of one token in one pool, before it is merged. */
+interface RewardPart {
+  pool: Address;
+  poolToken: Token;
+  token: Token;
+  value: bigint;
+  /** USD price of one whole token, as the source sends it. */
+  price: number | string | null | undefined;
+}
+/**
+ * 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.
+ */
+declare function resolvePool(sdk: RewardsSdk): (address: string | undefined) => {
+  pool: `0x${string}`;
+  poolToken: Token;
+} | undefined;
+/** Sources send amounts as free-form strings, which `toBigInt` throws on. */
+declare function parseAmount(value: string | undefined): bigint | undefined;
+/** What is left of `total` after `claimed`, when anything is. */
+declare function remaining(total: bigint | undefined, claimed: bigint | undefined): bigint | undefined;
+/**
+ * An incentive token is rarely protocol collateral, so the registry usually
+ * has no entry for it — and both sources always name it.
+ */
+declare function toRewardToken(sdk: RewardsSdk, address: Address, named: {
+  symbol: string;
+  name?: string;
+  decimals: number;
+}): Token;
+/**
+ * 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.
+ */
+declare function mergeRewards(sdk: RewardsSdk, source: MerklReward["source"], parts: readonly RewardPart[]): MerklReward[];
+//#endregion
+export { RewardPart, mergeRewards, parseAmount, remaining, resolvePool, toRewardToken };

package/dist/types/rewards/index.d.ts

@@ -1,6 +1,6 @@
+import { MerklReward, PointsReward, Reward } from "./types.js";
+import { RewardsService } from "./RewardsService.js";
 import { MerklRequestFailedError, TurtleRequestFailedError } from "./errors.js";
 import { MerkleXYZUserRewardsV4Response } from "./merkl-api.js";
-import { MerklReward, PointsReward, Reward } from "./toMerklRewards.js";
-import { GetRewardsMultichainProps, getRewardsMultichain } from "./multichain.js";
 import { TurtleWalletRewards } from "./turtle-api.js";
-export { GetRewardsMultichainProps, MerklRequestFailedError, type MerklReward, type MerkleXYZUserRewardsV4Response, type PointsReward, type Reward, TurtleRequestFailedError, type TurtleWalletRewards, getRewardsMultichain };
+export { MerklRequestFailedError, type MerklReward, type MerkleXYZUserRewardsV4Response, type PointsReward, type Reward, RewardsService, TurtleRequestFailedError, type TurtleWalletRewards };

package/dist/types/rewards/merkl-api.d.ts

@@ -38,10 +38,6 @@ interface MerkleXYZChain {
   name: string;
   icon: string;
 }
-/**
- * Merkl's own host and the Angle mirror, tried in this order.
- */
-declare const MERKL_DOMAINS: readonly ["https://api.merkl.xyz", "https://api-merkl.angle.money"];
 declare const MERKL_API_KEY_HEADER = "X-API-Key";
 interface FetchMerklUserRewardsProps {
   chainId: ChainId;
@@ -53,12 +49,11 @@ interface FetchMerklUserRewardsProps {
 /**
  * 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.
  */
 declare function fetchMerklUserRewards({ chainId, user, apiKey }: FetchMerklUserRewardsProps): Promise<MerkleXYZUserRewardsV4Response>;
 //#endregion
-export { FetchMerklUserRewardsProps, MERKL_API_KEY_HEADER, MERKL_DOMAINS, MerkleXYZUserRewardsV4, MerkleXYZUserRewardsV4Response, fetchMerklUserRewards };
+export { FetchMerklUserRewardsProps, MERKL_API_KEY_HEADER, MerkleXYZUserRewardsV4, MerkleXYZUserRewardsV4Response, fetchMerklUserRewards };

package/dist/types/rewards/toMerklRewards.d.ts

@@ -1,54 +1,11 @@
-import { ChainId, Token, TokenAmount } from "../model/primitives.js";
-import { PointsProgramPnL } from "../model/positions.js";
-import "../model/index.js";
-import { OnchainSDK } from "../onchain/OnchainSDK.js";
-import "../onchain/index.js";
+import { MerklReward, RewardsSdk } from "./types.js";
 import { MerkleXYZUserRewardsV4Response } from "./merkl-api.js";
-import { Address } from "viem";
 //#region src/rewards/toMerklRewards.d.ts
 /**
- * One claimable Merkl liquidity-mining reward, denominated and priced.
- *
- * Both tokens arrive resolved, so a consumer neither looks one up nor
- * reassembles one out of the loose fields Merkl sends.
- */
-interface MerklReward {
-  /** Where the reward is claimed. */
-  readonly source: "merkl" | "turtle";
-  readonly chainId: ChainId;
-  /** Market pool whose depositors the campaign rewards. */
-  readonly pool: Address;
-  /** That pool's share token — what the campaign is keyed on. */
-  readonly poolToken: Token;
-  /**
-   * The incentive token being handed out, how much of it is claimable
-   * (distributed minus already claimed, always > 0) and what that is worth.
-   *
-   * Priced by Merkl, not by the market oracles: a campaign's incentive token
-   * is rarely collateral in the pool it incentivises, so the oracles usually
-   * do not know it — GEAR, which most Gearbox campaigns pay in, among them.
-   * `valueUsd` is `null` for a token Merkl does not price either.
-   */
-  readonly amount: TokenAmount;
-}
-/** Points have no token and no price, and are not claimed. */
-interface PointsReward extends Omit<MerklReward, "amount"> {
-  readonly points: PointsProgramPnL;
-}
-type Reward = MerklReward | PointsReward;
-type RewardsSdk = Pick<OnchainSDK, "chainId" | "marketRegister" | "tokensMeta">;
-/**
- * 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.
  */
 declare function toMerklRewards(sdk: RewardsSdk, response: MerkleXYZUserRewardsV4Response): MerklReward[];
-/**
- * An incentive token is rarely protocol collateral, so the registry usually
- * has no entry for it — and both sources always name it.
- */
-declare function toRewardToken(sdk: RewardsSdk, address: Address, named: {
-  symbol: string;
-  name?: string;
-  decimals: number;
-}): Token;
 //#endregion
-export { MerklReward, PointsReward, Reward, RewardsSdk, toMerklRewards, toRewardToken };
+export { toMerklRewards };

package/dist/types/rewards/toTurtleRewards.d.ts

@@ -1,9 +1,9 @@
-import { Reward, RewardsSdk } from "./toMerklRewards.js";
+import { Reward, RewardsSdk } from "./types.js";
 import { TurtleWalletRewards } from "./turtle-api.js";
 //#region src/rewards/toTurtleRewards.d.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.
  */
 declare function toTurtleRewards(sdk: RewardsSdk, { streams, proofs }: TurtleWalletRewards, claimed: ReadonlyMap<string, bigint>): Reward[];
 //#endregion

package/dist/types/rewards/turtle-api.d.ts

@@ -1,3 +1,5 @@
+import { OnchainSDK } from "../onchain/OnchainSDK.js";
+import "../onchain/index.js";
 import { Address } from "viem";
 //#region src/rewards/turtle-api.d.ts
 interface TurtleWalletStream {
@@ -58,5 +60,7 @@ declare const turtleStreamAbi: readonly [{
   }];
 }];
 declare function fetchTurtleWalletRewards(user: Address, apiKey: string): Promise<TurtleWalletRewards>;
+/** What each of the wallet's streams on the chain has paid out, at the latest block. */
+declare function readTurtleClaimed(sdk: OnchainSDK, user: Address, { proofs }: TurtleWalletRewards): Promise<Map<string, bigint>>;
 //#endregion
-export { TurtleMerkleProof, TurtleWalletRewards, TurtleWalletStream, fetchTurtleWalletRewards, turtleStreamAbi };
+export { TurtleMerkleProof, TurtleWalletRewards, TurtleWalletStream, fetchTurtleWalletRewards, readTurtleClaimed, turtleStreamAbi };