@talismn/balances 3.1.0 → 3.1.2

package/dist/index.mjs

@@ -3,7 +3,7 @@ import { EvmErc20TokenSchema, EvmNativeTokenSchema, EvmUniswapV2TokenSchema, MIN
 import { frontierH160ToSs58Mirror, frontierSs58ToTruncatedH160, getAccountPlatformFromAddress, isAddressEqual, isEthereumAddress, isOnCurveSolanaAddress, isSolanaAddress, normalizeAddress } from "@talismn/crypto";
 import { BigMath, LruMap, createTimeSlicer, forEachWithYield, getErrorMessage, getSharedObservable, isAbortError, isArrayOf, isBigInt, isErrorOfName, isNotNil, isTruthy, keepAlive, mapWithYield, planckToTokens, reportJsActivity, switchMapChunked, yieldToEventLoop } from "@talismn/util";
 import { assign, fromPairs, isEqual, keyBy, keys, mergeWith, omit, toPairs, uniq, values } from "lodash-es";
-import { BehaviorSubject, EMPTY, Observable, ReplaySubject, auditTime, catchError, combineLatest, defer, distinctUntilChanged, filter, firstValueFrom, from, map, of, shareReplay, startWith, switchMap, tap, timer } from "rxjs";
+import { BehaviorSubject, EMPTY, Observable, ReplaySubject, auditTime, catchError, combineLatest, defer, distinctUntilChanged, filter, firstValueFrom, from, map, of, retry, shareReplay, startWith, switchMap, tap, timer } from "rxjs";
 import { encodeFunctionData, erc20Abi, erc20Abi_bytes32, getContract, hexToString, parseAbi, withRetry } from "viem";
 import { newTokenRates } from "@talismn/token-rates";
 import anylogger from "anylogger";
@@ -1666,18 +1666,31 @@ const fetchRpcQueryPack = async (connector, networkId, queries, at) => {
 	return decodeRpcQueryPackChunked(queries, new Map(result.changes), { label: `rpcQueryPack decode ${networkId}` });
 };
 /**
+* The connector reports a chain that has been unreachable for a while with a StaleRpcError,
+* but keeps the subscription registered and re-issues it when a socket reconnects (the
+* first notification after that is a full snapshot again). Matched by its `type` rather
+* than `instanceof`, so a second copy of @talismn/chain-connectors still matches.
+*/
+const isStaleRpcError = (error) => typeof error === "object" && error !== null && error.type === "STALE_RPC_ERROR";
+/**
 * Wraps the raw state_subscribeStorage subscription and emits, for every storage change
 * callback, a SNAPSHOT of the accumulated changes keyed by state key.
 *
 * A snapshot (shallow copy of string refs, cheap) is required because decoding is chunked
 * and asynchronous: a later websocket callback must not mutate the map that an in-flight
 * decode is reading.
+*
+* A StaleRpcError does not end the stream. Erroring would unsubscribe, and with no
+* subscription holding the chain's socket, every later request (eg the dtao poll) would
+* open and close a socket of its own, starting from the network's first RPC each time.
 */
 const getRawStorageUpdates$ = (connector, networkId, allStateKeys, timeout) => new Observable((subscriber) => {
 	const changesCache = /* @__PURE__ */ new Map();
 	const promUnsub = connector.subscribe(networkId, "state_subscribeStorage", "state_storage", [allStateKeys], (error, result) => {
-		if (error) subscriber.error(error);
-		else if (result) {
+		if (error) {
+			if (isStaleRpcError(error)) log_default.warn(`Storage subscription stale on ${networkId}`);
+			else subscriber.error(error);
+		} else if (result) {
 			for (const [stateKey, encodedResult] of result.changes) changesCache.set(stateKey, encodedResult);
 			subscriber.next(new Map(changesCache));
 		}
@@ -2482,6 +2495,12 @@ const createBalanceStabilizer = (isEffectivelyEqual, options) => {
 	};
 };
 /**
+* Cross-module drift tolerance (see classifySmallAmountDrift): amounts moving by no more
+* than this classify as drift and re-emit at most once per stabilizer refresh interval.
+* Kept tight — a real incoming transfer above 0.01% of the position emits immediately.
+*/
+const GENERIC_DRIFT_TOLERANCE_BPS = 1n;
+/**
 * Default cross-module drift classifier: balances whose SHAPE is identical (same
 * address/token/status, same value set with same types/labels/metas) but whose amounts
 * moved by no more than `toleranceBps` classify as "drift" — continuously-moving
@@ -2706,7 +2725,7 @@ const fetchOnChainTokenData$1 = async (connector, tokenId) => {
 //#region src/modules/sol-spl/fetchBalances.ts
 const SPL_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
 const dynamicTokenMetadataCache$1 = new LruMap(1024);
-const associatedTokenAccountCache = new LruMap(1024);
+const associatedTokenAccountCache$1 = new LruMap(1024);
 const fetchBalances$8 = async ({ networkId, tokensWithAddresses, connector }) => {
 	if (!tokensWithAddresses.length) return {
 		success: [],
@@ -2726,7 +2745,7 @@ const fetchBalances$8 = async ({ networkId, tokensWithAddresses, connector }) =>
 				return {
 					mintAddress,
 					value,
-					isSpendable: value !== 0n && state !== "frozen" && d.pubkey === await getAssociatedTokenAccount(address$2, mintAddress)
+					isSpendable: value !== 0n && state !== "frozen" && d.pubkey === await getAssociatedTokenAccount$1(address$2, mintAddress)
 				};
 			} catch {
 				log_default.warn("Failed to parse token amount", {
@@ -2819,16 +2838,16 @@ const fetchBalances$8 = async ({ networkId, tokensWithAddresses, connector }) =>
 	};
 };
 const getBalanceKey$1 = (tokenId, address) => `${tokenId}:${address}`;
-const getAssociatedTokenAccount = async (owner, mint) => {
+const getAssociatedTokenAccount$1 = async (owner, mint) => {
 	const key = `${owner}:${mint}`;
-	const cached = associatedTokenAccountCache.get(key);
+	const cached = associatedTokenAccountCache$1.get(key);
 	if (cached) return cached;
 	const [associatedTokenAccount] = await findAssociatedTokenPda({
 		mint: address(mint),
 		owner: address(owner),
 		tokenProgram: TOKEN_PROGRAM_ADDRESS
 	});
-	associatedTokenAccountCache.set(key, associatedTokenAccount);
+	associatedTokenAccountCache$1.set(key, associatedTokenAccount);
 	return associatedTokenAccount;
 };
 //#endregion
@@ -3278,6 +3297,7 @@ const fetchOnChainTokenData = async (connector, tokenId) => {
 //#region src/modules/sol-token2022/fetchBalances.ts
 const TOKEN_2022_PROGRAM_ID = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
 const dynamicTokenMetadataCache = /* @__PURE__ */ new Map();
+const associatedTokenAccountCache = new LruMap(1024);
 const fetchBalances$7 = async ({ networkId, tokensWithAddresses, connector }) => {
 	if (!tokensWithAddresses.length) return {
 		success: [],
@@ -3289,19 +3309,15 @@ const fetchBalances$7 = async ({ networkId, tokensWithAddresses, connector }) =>
 	const knownTokenIds = new Set(tokensWithAddresses.map(([token]) => token.id));
 	const unknownMints = /* @__PURE__ */ new Set();
 	const balancesPerAddress = await Promise.all(accountAddresses.map(async (address$1) => {
-		const balances = (await rpc.getTokenAccountsByOwner(address(address$1), { programId: address(TOKEN_2022_PROGRAM_ID) }, { encoding: "jsonParsed" }).send()).value.map((d) => {
+		const tokenAccounts = await rpc.getTokenAccountsByOwner(address(address$1), { programId: address(TOKEN_2022_PROGRAM_ID) }, { encoding: "jsonParsed" }).send();
+		const tokenAccountHoldings = await Promise.all(tokenAccounts.value.map(async (d) => {
 			try {
-				const mintAddress = d.account.data.parsed.info.mint;
-				const value = d.account.data.parsed.info.tokenAmount.amount ?? "0";
-				const tokenId = solToken2022TokenId(networkId, mintAddress);
-				if (!knownTokenIds.has(tokenId) && value !== "0") unknownMints.add(mintAddress);
+				const { mint: mintAddress, state, tokenAmount } = d.account.data.parsed.info;
+				const value = BigInt(tokenAmount.amount ?? "0");
 				return {
-					tokenId,
-					networkId,
-					address: address$1,
-					source: MODULE_TYPE$7,
-					status: "live",
-					value
+					mintAddress,
+					value,
+					isSpendable: value !== 0n && state !== "frozen" && d.pubkey === await getAssociatedTokenAccount(address$1, mintAddress)
 				};
 			} catch {
 				log_default.warn("Failed to parse token amount", {
@@ -3310,7 +3326,36 @@ const fetchBalances$7 = async ({ networkId, tokensWithAddresses, connector }) =>
 				});
 				return null;
 			}
-		}).filter(isNotNil);
+		}));
+		const holdingsPerTokenId = /* @__PURE__ */ new Map();
+		for (const { mintAddress, value, isSpendable } of tokenAccountHoldings.filter(isNotNil)) {
+			const tokenId = solToken2022TokenId(networkId, mintAddress);
+			if (!knownTokenIds.has(tokenId) && value !== 0n) unknownMints.add(mintAddress);
+			const { total, spendable } = holdingsPerTokenId.get(tokenId) ?? {
+				total: 0n,
+				spendable: 0n
+			};
+			holdingsPerTokenId.set(tokenId, {
+				total: total + value,
+				spendable: spendable + (isSpendable ? value : 0n)
+			});
+		}
+		const balances = [...holdingsPerTokenId].map(([tokenId, { total, spendable }]) => ({
+			tokenId,
+			networkId,
+			address: address$1,
+			source: MODULE_TYPE$7,
+			status: "live",
+			...spendable === total ? { value: total.toString() } : { values: [{
+				type: "free",
+				label: "free",
+				amount: total.toString()
+			}, {
+				type: "locked",
+				label: "locked",
+				amount: (total - spendable).toString()
+			}] }
+		}));
 		setDetectedTokenIds(address$1, MODULE_TYPE$7, balances.map((b) => b.tokenId));
 		return [address$1, balances];
 	}));
@@ -3365,6 +3410,18 @@ const fetchBalances$7 = async ({ networkId, tokensWithAddresses, connector }) =>
 	};
 };
 const getBalanceKey = (tokenId, address) => `${tokenId}:${address}`;
+const getAssociatedTokenAccount = async (owner, mint) => {
+	const key = `${owner}:${mint}`;
+	const cached = associatedTokenAccountCache.get(key);
+	if (cached) return cached;
+	const [associatedTokenAccount] = await findAssociatedTokenPda({
+		mint: address(mint),
+		owner: address(owner),
+		tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
+	});
+	associatedTokenAccountCache.set(key, associatedTokenAccount);
+	return associatedTokenAccount;
+};
 //#endregion
 //#region src/modules/sol-token2022/fetchTokens.ts
 const fetchTokens$7 = async ({ networkId, tokens, connector, cache }) => {
@@ -4430,16 +4487,10 @@ const getTransferCallData$5 = ({ from, to, value, token, metadataRpc }) => {
 * dividend accrual on (nearly) every block; the display is informational */
 const CLAIM_DRIFT_TOLERANCE_BPS = 100n;
 /**
-* subnet staking positions auto-compound: dividend injections land once per subnet tempo
-* (staggered across subnets, so with many positions SOME position bumps on nearly every
-* poll). Moves up to this size classify as drift (surfaced within the refresh interval);
-* anything larger (a real stake/unstake) emits immediately.
-*/
-const STAKE_DRIFT_TOLERANCE_BPS = 100n;
-/**
 * dtao balances embed values that drift on (nearly) every block even when the user's
-* position is untouched: staking positions auto-compound, basket claimable quotes move,
-* and conviction locks decay.
+* position is untouched: basket claimable quotes move and conviction locks decay.
+* Stake itself only moves on dividend injections, once per subnet tempo, so every stake
+* move emits immediately.
 *
 * Without special handling, every 6s poll re-emits the full result set, which defeats
 * every distinctUntilChanged stage downstream and forces the whole pipeline
@@ -4490,7 +4541,6 @@ const classifyValue = (previous, next) => {
 		if (previous.label === "Claimable rewards") {
 			if (!isWithinDriftTolerance(previous.amount, next.amount, CLAIM_DRIFT_TOLERANCE_BPS)) drift = true;
 		} else if (previousLock) drift = true;
-		else if (isWithinDriftTolerance(previous.amount, next.amount, STAKE_DRIFT_TOLERANCE_BPS)) drift = true;
 		else return changed(`amount ${previous.amount}→${next.amount}`);
 	}
 	return { equivalence: drift ? "drift" : "equal" };
@@ -6773,12 +6823,8 @@ const fetchMiniMetadatas = async (chainConnector, chaindataProvider, chainId, sp
 };
 //#endregion
 //#region src/BalancesProvider.ts
-/**
-* Cross-module drift tolerance (see classifySmallAmountDrift): amounts moving by no more
-* than this classify as drift and re-emit at most once per stabilizer refresh interval.
-* Kept tight — a real incoming transfer above 0.1% of the position emits immediately.
-*/
-const GENERIC_DRIFT_TOLERANCE_BPS = 10n;
+/** Delay before resubscribing a substrate module stream that errored: 2s, doubling, capped at 1min */
+const substrateModuleRetryDelay = (retryCount) => timer(Math.min(6e4, 2e3 * 2 ** (retryCount - 1)));
 const DEFAULT_STORAGE = {
 	balances: [],
 	miniMetadatas: []
@@ -6916,7 +6962,10 @@ var BalancesProvider = class {
 				connector: this.#chainConnectors.substrate,
 				miniMetadata,
 				hasFrontierMirrorWithdraw
-			})), stabilizeModuleResults(mod.type === "substrate-dtao" ? void 0 : classifySmallAmountDrift(GENERIC_DRIFT_TOLERANCE_BPS)), catchError(() => EMPTY), tap((results) => {
+			})), stabilizeModuleResults(mod.type === "substrate-dtao" ? void 0 : classifySmallAmountDrift(GENERIC_DRIFT_TOLERANCE_BPS)), retry({
+				delay: (_error, retryCount) => substrateModuleRetryDelay(retryCount),
+				resetOnSuccess: true
+			}), tap((results) => {
 				reportJsActivity(`module ${mod.type} ${networkId} (${results.success.length})`);
 				if (results.dynamicTokens?.length) this.#chaindataProvider.registerDynamicTokens(results.dynamicTokens);
 			}), map((results) => ({