@talismn/balances 3.1.0 → 3.1.2

package/dist/index.js

@@ -1694,18 +1694,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 rxjs.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));
 		}
@@ -2510,6 +2523,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
@@ -2734,7 +2753,7 @@ const fetchOnChainTokenData$1 = async (connector, tokenId) => {
 //#region src/modules/sol-spl/fetchBalances.ts
 const SPL_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
 const dynamicTokenMetadataCache$1 = new _talismn_util.LruMap(1024);
-const associatedTokenAccountCache = new _talismn_util.LruMap(1024);
+const associatedTokenAccountCache$1 = new _talismn_util.LruMap(1024);
 const fetchBalances$8 = async ({ networkId, tokensWithAddresses, connector }) => {
 	if (!tokensWithAddresses.length) return {
 		success: [],
@@ -2754,7 +2773,7 @@ const fetchBalances$8 = async ({ networkId, tokensWithAddresses, connector }) =>
 				return {
 					mintAddress,
 					value,
-					isSpendable: value !== 0n && state !== "frozen" && d.pubkey === await getAssociatedTokenAccount(address, mintAddress)
+					isSpendable: value !== 0n && state !== "frozen" && d.pubkey === await getAssociatedTokenAccount$1(address, mintAddress)
 				};
 			} catch {
 				log_default.warn("Failed to parse token amount", {
@@ -2847,16 +2866,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 (0, _solana_program_token.findAssociatedTokenPda)({
 		mint: (0, _solana_kit.address)(mint),
 		owner: (0, _solana_kit.address)(owner),
 		tokenProgram: _solana_program_token.TOKEN_PROGRAM_ADDRESS
 	});
-	associatedTokenAccountCache.set(key, associatedTokenAccount);
+	associatedTokenAccountCache$1.set(key, associatedTokenAccount);
 	return associatedTokenAccount;
 };
 //#endregion
@@ -3306,6 +3325,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 _talismn_util.LruMap(1024);
 const fetchBalances$7 = async ({ networkId, tokensWithAddresses, connector }) => {
 	if (!tokensWithAddresses.length) return {
 		success: [],
@@ -3317,19 +3337,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) => {
-		const balances = (await rpc.getTokenAccountsByOwner((0, _solana_kit.address)(address), { programId: (0, _solana_kit.address)(TOKEN_2022_PROGRAM_ID) }, { encoding: "jsonParsed" }).send()).value.map((d) => {
+		const tokenAccounts = await rpc.getTokenAccountsByOwner((0, _solana_kit.address)(address), { programId: (0, _solana_kit.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 = (0, _talismn_chaindata_provider.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,
-					source: MODULE_TYPE$7,
-					status: "live",
-					value
+					mintAddress,
+					value,
+					isSpendable: value !== 0n && state !== "frozen" && d.pubkey === await getAssociatedTokenAccount(address, mintAddress)
 				};
 			} catch {
 				log_default.warn("Failed to parse token amount", {
@@ -3338,7 +3354,36 @@ const fetchBalances$7 = async ({ networkId, tokensWithAddresses, connector }) =>
 				});
 				return null;
 			}
-		}).filter(_talismn_util.isNotNil);
+		}));
+		const holdingsPerTokenId = /* @__PURE__ */ new Map();
+		for (const { mintAddress, value, isSpendable } of tokenAccountHoldings.filter(_talismn_util.isNotNil)) {
+			const tokenId = (0, _talismn_chaindata_provider.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,
+			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, MODULE_TYPE$7, balances.map((b) => b.tokenId));
 		return [address, balances];
 	}));
@@ -3393,6 +3438,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 (0, _solana_program_token.findAssociatedTokenPda)({
+		mint: (0, _solana_kit.address)(mint),
+		owner: (0, _solana_kit.address)(owner),
+		tokenProgram: _solana_program_token_2022.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 }) => {
@@ -4458,16 +4515,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
@@ -4518,7 +4569,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" };
@@ -6801,12 +6851,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) => (0, rxjs.timer)(Math.min(6e4, 2e3 * 2 ** (retryCount - 1)));
 const DEFAULT_STORAGE = {
 	balances: [],
 	miniMetadatas: []
@@ -6944,7 +6990,10 @@ var BalancesProvider = class {
 				connector: this.#chainConnectors.substrate,
 				miniMetadata,
 				hasFrontierMirrorWithdraw
-			})), stabilizeModuleResults(mod.type === "substrate-dtao" ? void 0 : classifySmallAmountDrift(GENERIC_DRIFT_TOLERANCE_BPS)), (0, rxjs.catchError)(() => rxjs.EMPTY), (0, rxjs.tap)((results) => {
+			})), stabilizeModuleResults(mod.type === "substrate-dtao" ? void 0 : classifySmallAmountDrift(GENERIC_DRIFT_TOLERANCE_BPS)), (0, rxjs.retry)({
+				delay: (_error, retryCount) => substrateModuleRetryDelay(retryCount),
+				resetOnSuccess: true
+			}), (0, rxjs.tap)((results) => {
 				(0, _talismn_util.reportJsActivity)(`module ${mod.type} ${networkId} (${results.success.length})`);
 				if (results.dynamicTokens?.length) this.#chaindataProvider.registerDynamicTokens(results.dynamicTokens);
 			}), (0, rxjs.map)((results) => ({