@gearbox-protocol/sdk 17.1.2 → 17.2.0

package/dist/cjs/rewards/errors.js

@@ -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/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");
 exports.MerklRequestFailedError = require_rewards_errors.MerklRequestFailedError;
-exports.getMerklRewardsMultichain = require_rewards_multichain.getMerklRewardsMultichain;
-exports.toMerklRewards = require_rewards_toMerklRewards.toMerklRewards;
+exports.TurtleRequestFailedError = require_rewards_errors.TurtleRequestFailedError;
+exports.getRewardsMultichain = require_rewards_multichain.getRewardsMultichain;

package/dist/cjs/rewards/multichain.js

@@ -3,38 +3,58 @@ const require_onchain_base_MultichainConstruct = require("../onchain/base/Multic
 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/multichain.ts
-/**
-* The fan-out itself. Private because rewards are not an SDK namespace yet:
-* the read is a free function, and this is only how it reaches `queryChains`.
-**/
-var MerklRewardsFanOut = class extends require_onchain_base_MultichainConstruct.MultichainConstruct {
-	async list(wallet, chainIds, apiKey) {
+var RewardsFanOut = class extends require_onchain_base_MultichainConstruct.MultichainConstruct {
+	async list({ wallet, chainIds, merklApiKey, turtleApiKey }) {
 		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) => require_rewards_toMerklRewards.toMerklRewards(sdk, await require_rewards_merkl_api.fetchMerklUserRewards({
-				chainId: sdk.chainId,
-				user,
-				apiKey
-			}))
+			run: async (sdk, block) => {
+				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))));
+				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 : []);
+			}
 		});
 	}
 };
+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 Merkl reward a wallet holds, across the chains the handle
-* carries.
-*
-* Answers the read model's own envelope, so a chain that could not be reached
-* is `status: "error"` in `meta.chains` while a chain with nothing to claim is
-* a `"success"` that contributed no rows. That distinction is the point: the
-* single-chain read this replaces resolved empty either way.
+* 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 getMerklRewardsMultichain({ sdk, wallet, chainIds, apiKey }) {
-	return new MerklRewardsFanOut(sdk).list(wallet, chainIds, apiKey);
+async function getRewardsMultichain({ sdk, ...props }) {
+	return new RewardsFanOut(sdk).list(props);
 }
 //#endregion
-exports.getMerklRewardsMultichain = getMerklRewardsMultichain;
+exports.getRewardsMultichain = getRewardsMultichain;

package/dist/cjs/rewards/toMerklRewards.js

@@ -60,6 +60,7 @@ function toAmounts(reason) {
 function toReward({ price, token, value, ...rest }) {
 	return {
 		...rest,
+		source: "merkl",
 		amount: {
 			token,
 			value,
@@ -68,18 +69,18 @@ function toReward({ price, token, value, ...rest }) {
 	};
 }
 /**
-* 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.
+* 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, merkl) {
+function toRewardToken(sdk, address, named) {
 	return sdk.tokensMeta.getToken(address) ?? {
 		chainId: sdk.chainId,
 		address,
-		symbol: merkl.symbol,
-		name: merkl.symbol,
-		decimals: merkl.decimals || 18
+		symbol: named.symbol,
+		name: named.name ?? named.symbol,
+		decimals: named.decimals || 18
 	};
 }
 //#endregion
 exports.toMerklRewards = toMerklRewards;
+exports.toRewardToken = toRewardToken;

package/dist/cjs/rewards/toTurtleRewards.js

@@ -0,0 +1,77 @@
+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");
+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.
+*/
+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 = {
+			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
+			}
+		});
+	}
+	return [...rows.values()];
+}
+function parse(amount) {
+	if (amount === void 0) return void 0;
+	try {
+		return require_onchain_utils_formatter.toBigInt(amount);
+	} catch {
+		return;
+	}
+}
+//#endregion
+exports.toTurtleRewards = toTurtleRewards;

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

@@ -0,0 +1,50 @@
+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);
+	}
+}
+//#endregion
+exports.fetchTurtleWalletRewards = fetchTurtleWalletRewards;
+exports.turtleStreamAbi = turtleStreamAbi;

package/dist/esm/rewards/errors.js

@@ -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/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 { getRewardsMultichain } from "./multichain.js";
+export { MerklRequestFailedError, TurtleRequestFailedError, getRewardsMultichain };

package/dist/esm/rewards/multichain.js

@@ -2,38 +2,58 @@ 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, turtleStreamAbi } from "./turtle-api.js";
 import { getAddress } from "viem";
 //#region src/rewards/multichain.ts
-/**
-* The fan-out itself. Private because rewards are not an SDK namespace yet:
-* the read is a free function, and this is only how it reaches `queryChains`.
-**/
-var MerklRewardsFanOut = class extends MultichainConstruct {
-	async list(wallet, chainIds, apiKey) {
+var RewardsFanOut = class extends MultichainConstruct {
+	async list({ wallet, chainIds, merklApiKey, turtleApiKey }) {
 		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) => toMerklRewards(sdk, await fetchMerklUserRewards({
-				chainId: sdk.chainId,
-				user,
-				apiKey
-			}))
+			run: async (sdk, block) => {
+				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))));
+				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 : []);
+			}
 		});
 	}
 };
+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 Merkl reward a wallet holds, across the chains the handle
-* carries.
-*
-* Answers the read model's own envelope, so a chain that could not be reached
-* is `status: "error"` in `meta.chains` while a chain with nothing to claim is
-* a `"success"` that contributed no rows. That distinction is the point: the
-* single-chain read this replaces resolved empty either way.
+* 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 getMerklRewardsMultichain({ sdk, wallet, chainIds, apiKey }) {
-	return new MerklRewardsFanOut(sdk).list(wallet, chainIds, apiKey);
+async function getRewardsMultichain({ sdk, ...props }) {
+	return new RewardsFanOut(sdk).list(props);
 }
 //#endregion
-export { getMerklRewardsMultichain };
+export { getRewardsMultichain };

package/dist/esm/rewards/toMerklRewards.js

@@ -59,6 +59,7 @@ function toAmounts(reason) {
 function toReward({ price, token, value, ...rest }) {
 	return {
 		...rest,
+		source: "merkl",
 		amount: {
 			token,
 			value,
@@ -67,18 +68,17 @@ function toReward({ price, token, value, ...rest }) {
 	};
 }
 /**
-* 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.
+* 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, merkl) {
+function toRewardToken(sdk, address, named) {
 	return sdk.tokensMeta.getToken(address) ?? {
 		chainId: sdk.chainId,
 		address,
-		symbol: merkl.symbol,
-		name: merkl.symbol,
-		decimals: merkl.decimals || 18
+		symbol: named.symbol,
+		name: named.name ?? named.symbol,
+		decimals: named.decimals || 18
 	};
 }
 //#endregion
-export { toMerklRewards };
+export { toMerklRewards, toRewardToken };

package/dist/esm/rewards/toTurtleRewards.js

@@ -0,0 +1,76 @@
+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 { 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.
+*/
+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 = {
+			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
+			}
+		});
+	}
+	return [...rows.values()];
+}
+function parse(amount) {
+	if (amount === void 0) return void 0;
+	try {
+		return toBigInt(amount);
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { toTurtleRewards };

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

@@ -0,0 +1,48 @@
+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);
+	}
+}
+//#endregion
+export { fetchTurtleWalletRewards, turtleStreamAbi };

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

@@ -14,5 +14,10 @@ declare class MerklRequestFailedError extends BaseError {
   readonly chainId: ChainId;
   constructor(chainId: ChainId, path: string, attempts: ReadonlyArray<[domain: string, cause: unknown]>);
 }
+/** Turtle answers for every chain at once, so this names no chain. */
+declare class TurtleRequestFailedError extends BaseError {
+  name: string;
+  constructor(path: string, cause: unknown);
+}
 //#endregion
-export { MerklRequestFailedError };
+export { MerklRequestFailedError, TurtleRequestFailedError };

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

@@ -1,4 +1,6 @@
-import { MerklRequestFailedError } from "./errors.js";
-import { MerklReward, MerklRewardsSdk, toMerklRewards } from "./toMerklRewards.js";
-import { GetMerklRewardsMultichainProps, getMerklRewardsMultichain } from "./multichain.js";
-export { GetMerklRewardsMultichainProps, MerklRequestFailedError, MerklReward, MerklRewardsSdk, getMerklRewardsMultichain, toMerklRewards };
+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 };

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

@@ -4,30 +4,25 @@ import "../model/index.js";
 import { PluginsMap } from "../onchain/plugins/types.js";
 import { MultichainSDK } from "../onchain/MultichainSDK.js";
 import "../onchain/index.js";
-import { MerklReward } from "./toMerklRewards.js";
+import { Reward } from "./toMerklRewards.js";
 import { Address } from "viem";
 //#region src/rewards/multichain.d.ts
-interface GetMerklRewardsMultichainProps<Plugins extends PluginsMap = {}> {
-  /** Handle whose chains are asked. */
+interface GetRewardsMultichainProps<Plugins extends PluginsMap = {}> {
   sdk: MultichainSDK<Plugins>;
-  /** Wallet whose claimable rewards to list. */
   wallet: Address;
-  /**
-   * Chains to ask, defaulting to every chain the handle carries.
-   **/
+  /** Defaults to every chain the handle carries. */
   chainIds?: ChainId[];
   /** Raises Merkl's rate limit; the keyless path answers too. */
-  apiKey?: string;
+  merklApiKey?: string;
+  /** Turtle is skipped without one: its API answers no keyless request. */
+  turtleApiKey?: string;
 }
 /**
- * Every claimable Merkl reward a wallet holds, across the chains the handle
- * carries.
- *
- * Answers the read model's own envelope, so a chain that could not be reached
- * is `status: "error"` in `meta.chains` while a chain with nothing to claim is
- * a `"success"` that contributed no rows. That distinction is the point: the
- * single-chain read this replaces resolved empty either way.
+ * 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.
  **/
-declare function getMerklRewardsMultichain<const Plugins extends PluginsMap = {}>({ sdk, wallet, chainIds, apiKey }: GetMerklRewardsMultichainProps<Plugins>): Promise<DataResponse<MerklReward[]>>;
+declare function getRewardsMultichain<const Plugins extends PluginsMap = {}>({ sdk, ...props }: GetRewardsMultichainProps<Plugins>): Promise<DataResponse<Reward[]>>;
 //#endregion
-export { GetMerklRewardsMultichainProps, getMerklRewardsMultichain };
+export { GetRewardsMultichainProps, getRewardsMultichain };

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

@@ -1,4 +1,5 @@
 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";
@@ -12,6 +13,8 @@ import { Address } from "viem";
  * 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;
@@ -28,15 +31,24 @@ interface MerklReward {
    */
   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">;
 /**
- * What the mapping needs off a chain's SDK: which chain the rows belong to,
- * the pools a campaign can be keyed on, and the registry that names their
- * tokens. Nothing else, and nothing asynchronous.
+ * Merkl's answer for one chain, turned into rows of the read model.
  */
-type MerklRewardsSdk = Pick<OnchainSDK, "chainId" | "marketRegister" | "tokensMeta">;
+declare function toMerklRewards(sdk: RewardsSdk, response: MerkleXYZUserRewardsV4Response): MerklReward[];
 /**
- * Merkl's answer for one chain, turned into rows of the read model.
+ * An incentive token is rarely protocol collateral, so the registry usually
+ * has no entry for it — and both sources always name it.
  */
-declare function toMerklRewards(sdk: MerklRewardsSdk, response: MerkleXYZUserRewardsV4Response): MerklReward[];
+declare function toRewardToken(sdk: RewardsSdk, address: Address, named: {
+  symbol: string;
+  name?: string;
+  decimals: number;
+}): Token;
 //#endregion
-export { MerklReward, MerklRewardsSdk, toMerklRewards };
+export { MerklReward, PointsReward, Reward, RewardsSdk, toMerklRewards, toRewardToken };

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

@@ -0,0 +1,10 @@
+import { Reward, RewardsSdk } from "./toMerklRewards.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.
+ */
+declare function toTurtleRewards(sdk: RewardsSdk, { streams, proofs }: TurtleWalletRewards, claimed: ReadonlyMap<string, bigint>): Reward[];
+//#endregion
+export { toTurtleRewards };

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

@@ -0,0 +1,62 @@
+import { Address } from "viem";
+//#region src/rewards/turtle-api.d.ts
+interface TurtleWalletStream {
+  streamId: string;
+  snapshots: Array<{
+    rewardsAccumulated: string;
+  }>;
+  stream: {
+    orgId: string;
+    contractAddress: Address | null;
+    /** For Gearbox the target is a pool's share token. */
+    customArgs: {
+      targetToken?: {
+        address: Address;
+        chain: {
+          chainId: string;
+        };
+      };
+    };
+    point?: {
+      id: string;
+      name: string;
+      decimals: number;
+    } | null;
+    rewardToken: {
+      address: Address;
+      symbol: string;
+      name: string;
+      decimals: number;
+    } | null;
+    lastSnapshot: {
+      rewardTokenPrice: string | null;
+    } | null;
+  };
+}
+interface TurtleMerkleProof {
+  streamId: string;
+  chainId: number;
+  contractAddress: Address;
+  /** Cumulative committed allocation, not what is left to claim. */
+  amount: string;
+}
+interface TurtleWalletRewards {
+  streams: TurtleWalletStream[];
+  proofs: TurtleMerkleProof[];
+}
+declare const turtleStreamAbi: readonly [{
+  readonly type: "function";
+  readonly name: "getClaimedRewards";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [{
+    readonly name: "user";
+    readonly type: "address";
+  }];
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly type: "uint256";
+  }];
+}];
+declare function fetchTurtleWalletRewards(user: Address, apiKey: string): Promise<TurtleWalletRewards>;
+//#endregion
+export { TurtleMerkleProof, TurtleWalletRewards, TurtleWalletStream, fetchTurtleWalletRewards, turtleStreamAbi };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "17.1.2",
+  "version": "17.2.0",
   "description": "Gearbox SDK",
   "license": "MIT",
   "repository": {