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

package/dist/types/onchain/accounts/intents/maxBorrow.d.ts

@@ -30,18 +30,16 @@ interface MaxBorrowProps {
  * 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.

package/dist/types/onchain/market/credit/CreditSuite.d.ts

@@ -194,7 +194,7 @@ declare class CreditSuite extends SDKConstruct {
    */
   isForbidden(token: Address): boolean;
   /**
-   * 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:
@@ -203,27 +203,8 @@ declare class CreditSuite extends SDKConstruct {
    * - the facade's per-account `maxDebt`.
    * While `maxDebtPerBlockMultiplier` is `0` the facade
    * takes no new debt at all, so the answer is `0`.
-   *
-   * These are the bounds every debt increase answers to, an existing account's
-   * included, which is what the guards hold a simulation to. Opening a position
-   * answers to two more — see {@link maxStrategyBorrowAmount}.
    */
   maxBorrowAmount(): MaxBorrowAmount;
-  /**
-   * 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(): MaxBorrowAmount;
   /**
    * The single target collateral of this suite's strategy, or `undefined` when
    * none can be resolved.

package/dist/types/onchain/market/pool/PoolQuotaKeeperV310Contract.d.ts

@@ -494,8 +494,6 @@ declare class PoolQuotaKeeperV310Contract extends BaseContract<abi> implements I
   /**
    * 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: Address): bigint;
   /**

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,12 @@ 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 {
+  name: string;
+  constructor(path: string, cause: unknown);
 }
 //#endregion
-export { MerklRequestFailedError };
+export { MerklRequestFailedError, TurtleRequestFailedError };

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,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 { MerklReward, PointsReward, Reward } from "./types.js";
+import { RewardsService } from "./RewardsService.js";
+import { MerklRequestFailedError, TurtleRequestFailedError } from "./errors.js";
+import { MerkleXYZUserRewardsV4Response } from "./merkl-api.js";
+import { TurtleWalletRewards } from "./turtle-api.js";
+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,42 +1,11 @@
-import { ChainId, Token, TokenAmount } from "../model/primitives.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.
+ * 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.
  */
-interface MerklReward {
-  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;
-}
-/**
- * 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.
- */
-type MerklRewardsSdk = Pick<OnchainSDK, "chainId" | "marketRegister" | "tokensMeta">;
-/**
- * Merkl's answer for one chain, turned into rows of the read model.
- */
-declare function toMerklRewards(sdk: MerklRewardsSdk, response: MerkleXYZUserRewardsV4Response): MerklReward[];
+declare function toMerklRewards(sdk: RewardsSdk, response: MerkleXYZUserRewardsV4Response): MerklReward[];
 //#endregion
-export { MerklReward, MerklRewardsSdk, toMerklRewards };
+export { toMerklRewards };

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

@@ -0,0 +1,10 @@
+import { Reward, RewardsSdk } from "./types.js";
+import { TurtleWalletRewards } from "./turtle-api.js";
+//#region src/rewards/toTurtleRewards.d.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.
+ */
+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,66 @@
+import { OnchainSDK } from "../onchain/OnchainSDK.js";
+import "../onchain/index.js";
+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>;
+/** 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, readTurtleClaimed, turtleStreamAbi };

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

@@ -0,0 +1,41 @@
+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 { Address } from "viem";
+//#region src/rewards/types.d.ts
+/**
+ * One claimable token reward, denominated and priced.
+ *
+ * Both tokens arrive resolved, so a consumer neither looks one up nor
+ * reassembles one out of the loose fields a source 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 the source, 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 the source 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;
+/** What the mapping needs off a chain's SDK, and nothing asynchronous. */
+type RewardsSdk = Pick<OnchainSDK, "chainId" | "marketRegister" | "tokensMeta">;
+//#endregion
+export { MerklReward, PointsReward, Reward, RewardsSdk };

package/package.json

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

package/dist/cjs/rewards/multichain.js

@@ -1,40 +0,0 @@
-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");
-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) {
-		const user = (0, viem.getAddress)(wallet);
-		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
-			}))
-		});
-	}
-};
-/**
-* 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.
-**/
-async function getMerklRewardsMultichain({ sdk, wallet, chainIds, apiKey }) {
-	return new MerklRewardsFanOut(sdk).list(wallet, chainIds, apiKey);
-}
-//#endregion
-exports.getMerklRewardsMultichain = getMerklRewardsMultichain;

package/dist/esm/rewards/multichain.js

@@ -1,39 +0,0 @@
-import { MultichainConstruct } from "../onchain/base/MultichainConstruct.js";
-import "../onchain/index.js";
-import { fetchMerklUserRewards } from "./merkl-api.js";
-import { toMerklRewards } from "./toMerklRewards.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) {
-		const user = getAddress(wallet);
-		return this.queryChains({
-			chainIds,
-			label: "list rewards",
-			block: "state",
-			run: async (sdk) => toMerklRewards(sdk, await fetchMerklUserRewards({
-				chainId: sdk.chainId,
-				user,
-				apiKey
-			}))
-		});
-	}
-};
-/**
-* 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.
-**/
-async function getMerklRewardsMultichain({ sdk, wallet, chainIds, apiKey }) {
-	return new MerklRewardsFanOut(sdk).list(wallet, chainIds, apiKey);
-}
-//#endregion
-export { getMerklRewardsMultichain };

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

@@ -1,33 +0,0 @@
-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 "../onchain/index.js";
-import { MerklReward } from "./toMerklRewards.js";
-import { Address } from "viem";
-//#region src/rewards/multichain.d.ts
-interface GetMerklRewardsMultichainProps<Plugins extends PluginsMap = {}> {
-  /** Handle whose chains are asked. */
-  sdk: MultichainSDK<Plugins>;
-  /** Wallet whose claimable rewards to list. */
-  wallet: Address;
-  /**
-   * Chains to ask, defaulting to every chain the handle carries.
-   **/
-  chainIds?: ChainId[];
-  /** Raises Merkl's rate limit; the keyless path answers too. */
-  apiKey?: 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.
- **/
-declare function getMerklRewardsMultichain<const Plugins extends PluginsMap = {}>({ sdk, wallet, chainIds, apiKey }: GetMerklRewardsMultichainProps<Plugins>): Promise<DataResponse<MerklReward[]>>;
-//#endregion
-export { GetMerklRewardsMultichainProps, getMerklRewardsMultichain };