@defisaver/positions-sdk 2.1.167 → 2.1.168-stable-pair-dev

package/src/portfolio/lendingSummaryTransport.ts

@@ -0,0 +1,84 @@
+import {
+  decodeFunctionData, decodeFunctionResult, encodeFunctionData, encodeFunctionResult, multicall3Abi,
+} from 'viem';
+import { EthereumProvider } from '../types/common';
+
+const errorText = (error: unknown) => {
+  const detail = error as { message?: string; code?: number; status?: number };
+  return `${detail?.message || String(error)} ${detail?.code || ''} ${detail?.status || ''}`;
+};
+const logRangeLimit = (error: unknown) => /block range|too many (results|logs)|query returned|response.*size|range.*limit/i.test(errorText(error));
+const oversized = (error: unknown) => /413|request.*(large|size)|response.*(large|size)|out of gas|gas (required|limit)|exceeds.*gas|execution.*limit/i.test(errorText(error));
+
+export const isLendingSummaryRateLimit = (error: unknown): boolean => !oversized(error) && !logRangeLimit(error) && /429|rate.?limit|too many requests|compute units|limit exceeded/i.test(errorText(error));
+
+/** One limiter for all reads, including split multicalls. No retries after cancellation/429. */
+export function lendingSummaryTransport(provider: EthereumProvider, signal?: AbortSignal, blockNumber?: bigint, maxCalldataBytes = 32_000) {
+  let pinnedBlock = blockNumber;
+  let active = 0;
+  let rateLimit: unknown;
+  const waiting: (() => void)[] = [];
+  const check = () => {
+    if (signal?.aborted) throw new Error('Lending summary cancelled');
+    // Keep the provider's original error code/message, including plain RPC error objects.
+    // eslint-disable-next-line @typescript-eslint/no-throw-literal
+    if (rateLimit !== undefined) throw rateLimit;
+  };
+  const send = async (args: Parameters<EthereumProvider['request']>[0]) => {
+    if (active >= 4) await new Promise<void>(resolve => { waiting.push(resolve); });
+    else active++;
+    try {
+      check();
+      return await provider.request(args);
+    } catch (error) {
+      if (isLendingSummaryRateLimit(error)) rateLimit = error;
+      throw error;
+    } finally {
+      const next = waiting.shift();
+      if (next) next();
+      else active--;
+    }
+  };
+  const request: EthereumProvider['request'] = async (args) => {
+    check();
+    const params = [...(args.params || [])] as any[];
+    if (pinnedBlock !== undefined) {
+      const block = `0x${pinnedBlock.toString(16)}`;
+      if (args.method === 'eth_blockNumber') return block;
+      if (['eth_call', 'eth_getCode'].includes(args.method)) params[1] = block;
+    }
+    const call = params[0];
+    const isMulticall = args.method === 'eth_call' && call?.data?.startsWith('0x82ad56cb');
+    const splitMulticall = async (error: unknown) => {
+      const { args: [calls] } = decodeFunctionData({ abi: multicall3Abi, data: call.data });
+      if (!calls || calls.length < 2) throw error;
+      // Sequential halves keep the same concurrency bound and retain per-call failures.
+      const results = [];
+      for (const half of [calls.slice(0, Math.ceil(calls.length / 2)), calls.slice(Math.ceil(calls.length / 2))]) {
+        const data = encodeFunctionData({ abi: multicall3Abi, functionName: 'aggregate3', args: [half] });
+        const encoded = await request({ ...args, params: [{ ...call, data }, ...params.slice(1)] });
+        results.push(...decodeFunctionResult({ abi: multicall3Abi, functionName: 'aggregate3', data: encoded }));
+      }
+      return encodeFunctionResult({ abi: multicall3Abi, functionName: 'aggregate3', result: results });
+    };
+    // Viem's batch size counts inner calls only. Also bound the fully encoded calldata.
+    if (isMulticall && (call.data.length - 2) / 2 > maxCalldataBytes) return splitMulticall(new Error('Single call exceeds summary calldata limit'));
+    try {
+      return await send({ ...args, params });
+    } catch (error) {
+      check();
+      if (args.method === 'eth_getLogs' && logRangeLimit(error)) {
+        const from = BigInt(call.fromBlock);
+        const to = BigInt(call.toBlock);
+        if (from >= to) throw error;
+        const middle = (from + to) / BigInt(2);
+        const first = await request({ ...args, params: [{ ...call, toBlock: `0x${middle.toString(16)}` }] });
+        const last = await request({ ...args, params: [{ ...call, fromBlock: `0x${(middle + BigInt(1)).toString(16)}` }] });
+        return [...first, ...last];
+      }
+      if (!isMulticall || !oversized(error)) throw error;
+      return splitMulticall(error);
+    }
+  };
+  return { provider: { request } as EthereumProvider, isRateLimited: () => rateLimit !== undefined, pinBlock: (value: bigint) => { pinnedBlock = value; } };
+}

package/src/spark/index.ts

@@ -1,11 +1,12 @@
 import Dec from 'decimal.js';
 import { assetAmountInEth, assetAmountInWei, getAssetInfo } from '@defisaver/tokens';
 import { Client } from 'viem';
+import { getAaveLikeBalances } from '../helpers/aaveBalances';
 import {
   Blockish, EthAddress, EthereumProvider, IncentiveKind, NetworkNumber, PositionBalances,
 } from '../types/common';
 import {
-  ethToWeth, wethToEth, wethToEthByAddress,
+  ethToWeth, wethToEth,
 } from '../services/utils';
 import {
   calculateNetApy, getStakingApy, STAKING_ASSETS,
@@ -269,54 +270,7 @@ export const EMPTY_SPARK_DATA = {
 };
 
 export const _getSparkAccountBalances = async (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress): Promise<PositionBalances> => {
-  let balances: PositionBalances = {
-    collateral: {},
-    debt: {},
-  };
-
-  if (!address) {
-    return balances;
-  }
-
-  const loanInfoContract = SparkViewContractViem(provider, network, block);
-
-  const market = SPARK_V1(network);
-  const marketAddress = market.providerAddress;
-  // @ts-ignore
-  const protocolDataProviderContract = createViemContractFromConfigFunc(market.protocolData, market.protocolDataAddress)(provider, network);
-
-  // @ts-ignore
-  const reserveTokens = await protocolDataProviderContract.read.getAllReservesTokens(setViemBlockNumber(block)) as { symbol: string, tokenAddress: EthAddress }[];
-  const symbols = reserveTokens.map(({ symbol }: { symbol: string }) => symbol);
-  const _addresses = reserveTokens.map(({ tokenAddress }: { tokenAddress: EthAddress }) => tokenAddress);
-
-
-  // split addresses in half to avoid gas limit by multicall
-  const middleAddressIndex = Math.floor(_addresses.length / 2);
-
-  const [tokenBalances1, tokenBalances2] = await Promise.all([
-    loanInfoContract.read.getTokenBalances([marketAddress, address, _addresses.slice(0, middleAddressIndex)], setViemBlockNumber(block)),
-    loanInfoContract.read.getTokenBalances([marketAddress, address, _addresses.slice(middleAddressIndex, _addresses.length)], setViemBlockNumber(block)),
-  ]);
-
-  const loanInfo = [...tokenBalances1, ...tokenBalances2];
-
-  loanInfo.forEach((tokenInfo: any, i: number) => {
-    const asset = wethToEth(symbols[i]);
-    const assetAddr = wethToEthByAddress(_addresses[i], network).toLowerCase();
-
-    balances = {
-      collateral: {
-        ...balances.collateral,
-        [addressMapping ? assetAddr : asset]: tokenInfo.balance.toString(),
-      },
-      debt: {
-        ...balances.debt,
-        [addressMapping ? assetAddr : asset]: new Dec(tokenInfo.borrowsStable.toString()).add(tokenInfo.borrowsVariable.toString()).toString(),
-      },
-    };
-  });
-
+  const balances = await getAaveLikeBalances(provider, network, block, addressMapping, address, SPARK_V1(network), 'SparkView');
   return balances;
 };
 

package/src/types/common.ts

@@ -26,6 +26,7 @@ export enum LeverageType {
   Short = 'short',
   VolatilePair = 'volatile-pair',
   VolatilePairReverse = 'volatile-pair-reverse',
+  StablePair = 'stable-pair',
   None = '',
 }
 

package/src/types/index.ts

@@ -14,4 +14,5 @@ export * from './merit';
 export * from './merkl';
 export * from './savings';
 export * from './common';
-export * from './aaveV4';
+export * from './aaveV4';
+export * from './lendingSummary';

package/src/types/lendingSummary.ts

@@ -0,0 +1,41 @@
+import { EthAddress, NetworkNumber } from './common';
+
+export type LendingSummaryPosition = {
+  id: string;
+  protocol: string;
+  /** Estimated decimal USD values; null means unavailable, never a verified zero. */
+  suppliedUsd: string | null;
+  debtUsd: string | null;
+};
+
+export type WalletLendingSummary = {
+  status: 'complete' | 'partial' | 'failed';
+  positions: LendingSummaryPosition[];
+  protocols: string[];
+  /** Sum of known supply values; check valuationComplete before ranking by value. */
+  suppliedUsd: string;
+  valuationComplete: boolean;
+  errors: string[];
+};
+
+/** Resolve distinct token addresses to USD prices keyed by lowercase address.
+ * Native tokens use their wrapped address. Missing/invalid prices remain unavailable.
+ * Prices are current market estimates; balances may come from a historical/fork snapshot.
+ */
+export type LendingSummaryPriceResolver = (
+  network: NetworkNumber, tokens: EthAddress[], signal?: AbortSignal,
+) => Promise<Record<string, string>>;
+
+export type LendingSummaryOptions = {
+  resolvePrices: LendingSummaryPriceResolver;
+  signal?: AbortSignal;
+  /** Defaults to a snapshot of the provider's latest block. */
+  blockNumber?: bigint;
+  /** Use the smaller 2 KB calldata limit required by simulation providers. */
+  isSim?: boolean;
+};
+
+export type WalletLendingSummaries = {
+  summaries: Record<string, WalletLendingSummary>;
+  rateLimited: boolean;
+};