@talismn/balances 0.0.0-pr2131-20250807071252 → 0.0.0-pr2134-20250813092023

package/dist/talismn-balances.esm.js

@@ -1,13 +1,18 @@
-import { EvmErc20TokenSchema, parseTokenId, parseEvmErc20TokenId, evmErc20TokenId, isTokenOfType, TokenBaseSchema, EvmNativeTokenSchema, evmNativeTokenId, EvmUniswapV2TokenSchema, evmUniswapV2TokenId, SubAssetsTokenSchema, subAssetTokenId, MINIMETADATA_VERSION, SubForeignAssetsTokenSchema, subForeignAssetTokenId, SubHydrationTokenSchema, subHydrationTokenId, SubNativeTokenSchema, subNativeTokenId, SubPsp22TokenSchema, subPsp22TokenId, SubTokensTokenSchema, subTokensTokenId, isNetworkDot } from '@talismn/chaindata-provider';
+import { EvmErc20TokenSchema, parseTokenId, parseEvmErc20TokenId, evmErc20TokenId, isTokenOfType, TokenBaseSchema, EvmNativeTokenSchema, evmNativeTokenId, EvmUniswapV2TokenSchema, evmUniswapV2TokenId, SolNativeTokenSchema, solNativeTokenId, SolSplTokenSchema, solSplTokenId, parseSolSplTokenId, SubAssetsTokenSchema, subAssetTokenId, MINIMETADATA_VERSION, SubForeignAssetsTokenSchema, subForeignAssetTokenId, SubHydrationTokenSchema, subHydrationTokenId, SubNativeTokenSchema, subNativeTokenId, SubPsp22TokenSchema, subPsp22TokenId, SubTokensTokenSchema, subTokensTokenId, isNetworkDot } from '@talismn/chaindata-provider';
 export { MINIMETADATA_VERSION } from '@talismn/chaindata-provider';
-import { isEthereumAddress, isNotNil, BigMath, isArrayOf, isBigInt, planckToTokens, isAbortError, getSharedObservable, keepAlive, isTruthy, normalizeAddress } from '@talismn/util';
+import { isEthereumAddress, isSolanaAddress, normalizeAddress, getAccountPlatformFromAddress } from '@talismn/crypto';
 import { parseAbi, erc20Abi, getContract, ContractFunctionExecutionError, hexToString, erc20Abi_bytes32, encodeFunctionData, withRetry } from 'viem';
 import { assign, omit, isEqual, uniq, keyBy, toPairs, keys, fromPairs, values } from 'lodash-es';
 import z from 'zod/v4';
 import anylogger from 'anylogger';
 import { of, Observable, distinctUntilChanged, map, timer, switchMap, from, firstValueFrom, combineLatest, BehaviorSubject, shareReplay, startWith, filter, defer, catchError, EMPTY, tap } from 'rxjs';
 import BigNumber from 'bignumber.js';
+import { PublicKey, SystemProgram } from '@solana/web3.js';
+import { isNotNil, BigMath, isArrayOf, isBigInt, planckToTokens, isAbortError, getSharedObservable, keepAlive, isTruthy } from '@talismn/util';
 import { parseMetadataRpc, toHex, unifyMetadata, decAnyMetadata, getDynamicBuilder, getLookupFn, decodeScale, getStorageKeyPrefix, Twox128, compactMetadata, encodeMetadata, papiParse, papiStringify } from '@talismn/scale';
+import { deserializeMetadata } from '@metaplex-foundation/mpl-token-metadata';
+import { sol, publicKey } from '@metaplex-foundation/umi';
+import { MintLayout, getAssociatedTokenAddress, createAssociatedTokenAccountInstruction, createTransferInstruction, TOKEN_PROGRAM_ID, getAccount } from '@solana/spl-token';
 import { newTokenRates } from '@talismn/token-rates';
 import { mergeUint8 } from '@polkadot-api/utils';
 import { Binary, Enum, AccountId } from 'polkadot-api';
@@ -19,8 +24,8 @@ import { u8aToHex, u8aConcatStrict, u8aToString, hexToNumber } from '@polkadot/u
 import PQueue from 'p-queue';
 import { fetchBestMetadata } from '@talismn/sapi';
 
-const MODULE_TYPE$8 = EvmErc20TokenSchema.shape.type.value;
-const PLATFORM$8 = EvmErc20TokenSchema.shape.platform.value;
+const MODULE_TYPE$a = EvmErc20TokenSchema.shape.type.value;
+const PLATFORM$a = EvmErc20TokenSchema.shape.platform.value;
 
 const abiMulticall = parseAbi(["struct Call { address target; bytes callData; }", "struct Call3 { address target; bool allowFailure; bytes callData; }", "struct Call3Value { address target; bool allowFailure; uint256 value; bytes callData; }", "struct Result { bool success; bytes returnData; }", "function aggregate(Call[] calldata calls) public payable returns (uint256 blockNumber, bytes[] memory returnData)", "function aggregate3(Call3[] calldata calls) public payable returns (Result[] memory returnData)", "function aggregate3Value(Call3Value[] calldata calls) public payable returns (Result[] memory returnData)", "function blockAndAggregate(Call[] calldata calls) public payable returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData)", "function getBasefee() view returns (uint256 basefee)", "function getBlockHash(uint256 blockNumber) view returns (bytes32 blockHash)", "function getBlockNumber() view returns (uint256 blockNumber)", "function getChainId() view returns (uint256 chainid)", "function getCurrentBlockCoinbase() view returns (address coinbase)", "function getCurrentBlockDifficulty() view returns (uint256 difficulty)", "function getCurrentBlockGasLimit() view returns (uint256 gaslimit)", "function getCurrentBlockTimestamp() view returns (uint256 timestamp)", "function getEthBalance(address addr) view returns (uint256 balance)", "function getLastBlockHash() view returns (bytes32 blockHash)", "function tryAggregate(bool requireSuccess, Call[] calldata calls) public payable returns (Result[] memory returnData)", "function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls) public payable returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData)"]);
 
@@ -616,7 +621,7 @@ const getBalanceDefs = addressesByToken => {
 // if there is at least one storage entry, the results will be an array with a single object
 // if the storage has no entries in it (ex: Assets on ewx or moonbeam), the response will be an empty array
 
-const fetchBalances$8 = async ({
+const fetchBalances$a = async ({
   networkId,
   tokensWithAddresses,
   connector
@@ -628,7 +633,7 @@ const fetchBalances$8 = async ({
   const client = await connector.getPublicClientForEvmNetwork(networkId);
   if (!client) throw new Error(`Could not get rpc provider for evm network ${networkId}`);
   for (const [token, addresses] of tokensWithAddresses) {
-    if (token.type !== MODULE_TYPE$8 || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for EVM ERC20 balance module: ${token.type} on ${token.networkId}`);
+    if (token.type !== MODULE_TYPE$a || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for EVM ERC20 balance module: ${token.type} on ${token.networkId}`);
     for (const address of addresses) if (!isEthereumAddress(address)) throw new Error(`Invalid ethereum address for EVM ERC20 balance module: ${address} for token ${token.id}`);
   }
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
@@ -658,7 +663,7 @@ const fetchWithoutAggregator = async (client, balanceDefs) => {
         address,
         tokenId: token.id,
         value: result.toString(),
-        source: MODULE_TYPE$8,
+        source: MODULE_TYPE$a,
         networkId: parseEvmErc20TokenId(token.id).networkId,
         status: "live"
       };
@@ -701,7 +706,7 @@ const fetchWithAggregator = async (client, balanceDefs, erc20BalancesAggregatorA
       address: balanceDef.address,
       tokenId: balanceDef.token.id,
       value: erc20Balances[index].toString(),
-      source: MODULE_TYPE$8,
+      source: MODULE_TYPE$a,
       networkId: parseTokenId(balanceDef.token.id).networkId,
       status: "live"
     }));
@@ -758,7 +763,7 @@ const getTypedContract$1 = (client, abi, contractAddress) => getContract({
   }
 });
 
-const TokenCacheSchema$1 = z.discriminatedUnion("isValid", [z.strictObject({
+const TokenCacheSchema$2 = z.discriminatedUnion("isValid", [z.strictObject({
   id: EvmErc20TokenSchema.shape.id,
   isValid: z.literal(true),
   ...EvmErc20TokenSchema.pick({
@@ -770,7 +775,7 @@ const TokenCacheSchema$1 = z.discriminatedUnion("isValid", [z.strictObject({
   id: EvmErc20TokenSchema.shape.id,
   isValid: z.literal(false)
 })]);
-const fetchTokens$8 = async ({
+const fetchTokens$a = async ({
   networkId,
   tokens,
   connector,
@@ -779,7 +784,7 @@ const fetchTokens$8 = async ({
   const result = [];
   for (const tokenConfig of tokens) {
     const tokenId = evmErc20TokenId(networkId, tokenConfig.contractAddress);
-    const cached = cache[tokenId] && TokenCacheSchema$1.safeParse(cache[tokenId]).data;
+    const cached = cache[tokenId] && TokenCacheSchema$2.safeParse(cache[tokenId]).data;
     if (!cached) {
       const client = await connector.getPublicClientForEvmNetwork(networkId);
       if (!client) {
@@ -792,7 +797,7 @@ const fetchTokens$8 = async ({
           decimals,
           symbol
         } = await getErc20ContractData$1(client, tokenConfig.contractAddress);
-        cache[tokenId] = TokenCacheSchema$1.parse({
+        cache[tokenId] = TokenCacheSchema$2.parse({
           id: tokenId,
           symbol,
           decimals,
@@ -810,11 +815,11 @@ const fetchTokens$8 = async ({
     }
     const base = {
       id: tokenId,
-      type: MODULE_TYPE$8,
-      platform: PLATFORM$8,
+      type: MODULE_TYPE$a,
+      platform: PLATFORM$a,
       networkId
     };
-    const cached2 = cache[tokenId] && TokenCacheSchema$1.safeParse(cache[tokenId]).data;
+    const cached2 = cache[tokenId] && TokenCacheSchema$2.safeParse(cache[tokenId]).data;
     if (cached2?.isValid === false) continue;
     const token = assign(base, cached2?.isValid ? omit(cached2, ["isValid"]) : {}, tokenConfig);
     const parsed = EvmErc20TokenSchema.safeParse(token);
@@ -829,17 +834,17 @@ const fetchTokens$8 = async ({
   return result;
 };
 
-const getMiniMetadata$8 = () => {
+const getMiniMetadata$a = () => {
   throw new Error("MiniMetadata is not supported for ethereum tokens");
 };
 
-const getTransferCallData$8 = ({
+const getTransferCallData$a = ({
   from,
   to,
   value,
   token
 }) => {
-  if (!isTokenOfType(token, MODULE_TYPE$8)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$8}.`);
+  if (!isTokenOfType(token, MODULE_TYPE$a)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$a}.`);
   if (!isEthereumAddress(from)) throw new Error("Invalid from address");
   if (!isEthereumAddress(to)) throw new Error("Invalid to address");
   const data = encodeFunctionData({
@@ -854,8 +859,8 @@ const getTransferCallData$8 = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$4 = 6_000;
-const subscribeBalances$8 = ({
+const SUBSCRIPTION_INTERVAL$6 = 6_000;
+const subscribeBalances$a = ({
   networkId,
   tokensWithAddresses,
   connector
@@ -869,17 +874,17 @@ const subscribeBalances$8 = ({
     const poll = async () => {
       try {
         if (abortController.signal.aborted) return;
-        const balances = await fetchBalances$8({
+        const balances = await fetchBalances$a({
           networkId,
           tokensWithAddresses: tokensWithAddresses,
           connector
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$4);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$6);
       } catch (error) {
         log.error("Error", {
-          module: MODULE_TYPE$8,
+          module: MODULE_TYPE$a,
           networkId,
           addressesByToken: tokensWithAddresses,
           error
@@ -895,13 +900,13 @@ const subscribeBalances$8 = ({
 };
 
 const EvmErc20BalanceModule = {
-  type: MODULE_TYPE$8,
-  platform: PLATFORM$8,
-  getMiniMetadata: getMiniMetadata$8,
-  fetchTokens: fetchTokens$8,
-  fetchBalances: fetchBalances$8,
-  subscribeBalances: subscribeBalances$8,
-  getTransferCallData: getTransferCallData$8
+  type: MODULE_TYPE$a,
+  platform: PLATFORM$a,
+  getMiniMetadata: getMiniMetadata$a,
+  fetchTokens: fetchTokens$a,
+  fetchBalances: fetchBalances$a,
+  subscribeBalances: subscribeBalances$a,
+  getTransferCallData: getTransferCallData$a
 };
 
 const TokenConfigBaseSchema = TokenBaseSchema.partial().omit({
@@ -914,10 +919,10 @@ const EvmErc20TokenConfigSchema = z.strictObject({
   ...TokenConfigBaseSchema.shape
 });
 
-const MODULE_TYPE$7 = EvmNativeTokenSchema.shape.type.value;
-const PLATFORM$7 = EvmNativeTokenSchema.shape.platform.value;
+const MODULE_TYPE$9 = EvmNativeTokenSchema.shape.type.value;
+const PLATFORM$9 = EvmNativeTokenSchema.shape.platform.value;
 
-const fetchBalances$7 = async ({
+const fetchBalances$9 = async ({
   networkId,
   tokensWithAddresses,
   connector
@@ -929,7 +934,7 @@ const fetchBalances$7 = async ({
   const client = await connector.getPublicClientForEvmNetwork(networkId);
   if (!client) throw new Error(`Could not get rpc provider for evm network ${networkId}`);
   for (const [token, addresses] of tokensWithAddresses) {
-    if (token.type !== MODULE_TYPE$7 || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for EVM ERC20 balance module: ${token.type} on ${token.networkId}`);
+    if (token.type !== MODULE_TYPE$9 || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for EVM ERC20 balance module: ${token.type} on ${token.networkId}`);
     for (const address of addresses) if (!isEthereumAddress(address)) throw new Error(`Invalid ethereum address for EVM ERC20 balance module: ${address} for token ${token.id}`);
   }
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
@@ -956,7 +961,7 @@ const fetchWithoutMulticall = async (client, balanceDefs) => {
         address,
         tokenId: token.id,
         value: result.toString(),
-        source: MODULE_TYPE$7,
+        source: MODULE_TYPE$9,
         networkId: parseTokenId(token.id).networkId,
         status: "live"
       };
@@ -1002,7 +1007,7 @@ const fetchWithMulticall = async (client, balanceDefs, multicall3Address) => {
           address: balanceDefs[index].address,
           tokenId: balanceDefs[index].token.id,
           value: result.result.toString(),
-          source: MODULE_TYPE$7,
+          source: MODULE_TYPE$9,
           networkId: parseTokenId(balanceDefs[index].token.id).networkId,
           status: "live"
         });
@@ -1032,7 +1037,7 @@ const fetchWithMulticall = async (client, balanceDefs, multicall3Address) => {
   }
 };
 
-const fetchTokens$7 = async ({
+const fetchTokens$9 = async ({
   networkId,
   tokens
 }) => {
@@ -1040,8 +1045,8 @@ const fetchTokens$7 = async ({
   if (tokens.length !== 1) throw new Error("EVM Native module expects the nativeCurrency to be passed as a single token in the array");
   const token = assign({
     id: evmNativeTokenId(networkId),
-    type: MODULE_TYPE$7,
-    platform: PLATFORM$7,
+    type: MODULE_TYPE$9,
+    platform: PLATFORM$9,
     networkId,
     isDefault: true
   }, tokens[0]);
@@ -1053,17 +1058,17 @@ const fetchTokens$7 = async ({
   return [parsed.data];
 };
 
-const getMiniMetadata$7 = () => {
+const getMiniMetadata$9 = () => {
   throw new Error("MiniMetadata is not supported for ethereum tokens");
 };
 
-const getTransferCallData$7 = ({
+const getTransferCallData$9 = ({
   from,
   to,
   value,
   token
 }) => {
-  if (!isTokenOfType(token, MODULE_TYPE$7)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$7}.`);
+  if (!isTokenOfType(token, MODULE_TYPE$9)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$9}.`);
   if (!isEthereumAddress(from)) throw new Error("Invalid from address");
   if (!isEthereumAddress(to)) throw new Error("Invalid to address");
   return {
@@ -1074,8 +1079,8 @@ const getTransferCallData$7 = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$3 = 6_000;
-const subscribeBalances$7 = ({
+const SUBSCRIPTION_INTERVAL$5 = 6_000;
+const subscribeBalances$9 = ({
   networkId,
   tokensWithAddresses,
   connector
@@ -1089,17 +1094,17 @@ const subscribeBalances$7 = ({
     const poll = async () => {
       try {
         if (abortController.signal.aborted) return;
-        const balances = await fetchBalances$7({
+        const balances = await fetchBalances$9({
           networkId,
           tokensWithAddresses: tokensWithAddresses,
           connector
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$3);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$5);
       } catch (error) {
         log.error("Error", {
-          module: MODULE_TYPE$7,
+          module: MODULE_TYPE$9,
           networkId,
           addressesByToken: tokensWithAddresses,
           error
@@ -1115,13 +1120,13 @@ const subscribeBalances$7 = ({
 };
 
 const EvmNativeBalanceModule = {
-  type: MODULE_TYPE$7,
-  platform: PLATFORM$7,
-  getMiniMetadata: getMiniMetadata$7,
-  fetchTokens: fetchTokens$7,
-  fetchBalances: fetchBalances$7,
-  subscribeBalances: subscribeBalances$7,
-  getTransferCallData: getTransferCallData$7
+  type: MODULE_TYPE$9,
+  platform: PLATFORM$9,
+  getMiniMetadata: getMiniMetadata$9,
+  fetchTokens: fetchTokens$9,
+  fetchBalances: fetchBalances$9,
+  subscribeBalances: subscribeBalances$9,
+  getTransferCallData: getTransferCallData$9
 };
 
 // to be used by chaindata too
@@ -1129,10 +1134,10 @@ const EvmNativeTokenConfigSchema = z.strictObject({
   ...TokenConfigBaseSchema.shape
 });
 
-const MODULE_TYPE$6 = EvmUniswapV2TokenSchema.shape.type.value;
-const PLATFORM$6 = EvmUniswapV2TokenSchema.shape.platform.value;
+const MODULE_TYPE$8 = EvmUniswapV2TokenSchema.shape.type.value;
+const PLATFORM$8 = EvmUniswapV2TokenSchema.shape.platform.value;
 
-const fetchBalances$6 = async ({
+const fetchBalances$8 = async ({
   networkId,
   tokensWithAddresses,
   connector
@@ -1144,7 +1149,7 @@ const fetchBalances$6 = async ({
   const client = await connector.getPublicClientForEvmNetwork(networkId);
   if (!client) throw new Error(`Could not get rpc provider for evm network ${networkId}`);
   for (const [token, addresses] of tokensWithAddresses) {
-    if (token.type !== MODULE_TYPE$6 || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for EVM ERC20 balance module: ${token.type} on ${token.networkId}`);
+    if (token.type !== MODULE_TYPE$8 || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for EVM ERC20 balance module: ${token.type} on ${token.networkId}`);
     for (const address of addresses) if (!isEthereumAddress(address)) throw new Error(`Invalid ethereum address for EVM ERC20 balance module: ${address} for token ${token.id}`);
   }
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
@@ -1231,7 +1236,7 @@ const fetchPoolBalances = async (client, balanceDefs) => {
     acc.success.push({
       address,
       tokenId: token.id,
-      source: MODULE_TYPE$6,
+      source: MODULE_TYPE$8,
       networkId: parseTokenId(token.id).networkId,
       status: "live",
       values: [{
@@ -1291,7 +1296,7 @@ const getUniswapV2PairContractData = async (client, contractAddress) => {
   };
 };
 
-const TokenCacheSchema = z.discriminatedUnion("isValid", [z.strictObject({
+const TokenCacheSchema$1 = z.discriminatedUnion("isValid", [z.strictObject({
   id: EvmUniswapV2TokenSchema.shape.id,
   isValid: z.literal(true),
   ...EvmUniswapV2TokenSchema.pick({
@@ -1309,7 +1314,7 @@ const TokenCacheSchema = z.discriminatedUnion("isValid", [z.strictObject({
   id: EvmUniswapV2TokenSchema.shape.id,
   isValid: z.literal(false)
 })]);
-const fetchTokens$6 = async ({
+const fetchTokens$8 = async ({
   networkId,
   tokens,
   connector,
@@ -1318,7 +1323,7 @@ const fetchTokens$6 = async ({
   const result = [];
   for (const tokenConfig of tokens) {
     const tokenId = evmUniswapV2TokenId(networkId, tokenConfig.contractAddress);
-    const cached = cache[tokenId] && TokenCacheSchema.safeParse(cache[tokenId]).data;
+    const cached = cache[tokenId] && TokenCacheSchema$1.safeParse(cache[tokenId]).data;
     if (!cached) {
       const client = await connector.getPublicClientForEvmNetwork(networkId);
       if (!client) {
@@ -1340,7 +1345,7 @@ const fetchTokens$6 = async ({
           symbol: symbol1,
           decimals: decimals1
         } = await getErc20ContractData(client, token1);
-        cache[tokenId] = TokenCacheSchema.parse({
+        cache[tokenId] = TokenCacheSchema$1.parse({
           id: tokenId,
           symbol: `${symbol0}/${symbol1}`,
           decimals,
@@ -1366,48 +1371,601 @@ const fetchTokens$6 = async ({
         continue;
       }
     }
+    const base = {
+      id: tokenId,
+      type: MODULE_TYPE$8,
+      platform: PLATFORM$8,
+      networkId
+    };
+    const cached2 = cache[tokenId] && TokenCacheSchema$1.safeParse(cache[tokenId]).data;
+    if (cached2?.isValid === false) continue;
+    const token = assign(base, cached2?.isValid ? omit(cached2, ["isValid"]) : {}, tokenConfig);
+    const parsed = EvmUniswapV2TokenSchema.safeParse(token);
+    if (!parsed.success) {
+      log.warn("Ignoring token with invalid schema", token);
+      continue;
+    }
+    result.push(parsed.data);
+  }
+  return result;
+};
+
+const getMiniMetadata$8 = () => {
+  throw new Error("MiniMetadata is not supported for ethereum tokens");
+};
+
+const getTransferCallData$8 = ({
+  from,
+  to,
+  value,
+  token
+}) => {
+  if (!isTokenOfType(token, MODULE_TYPE$8)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$8}.`);
+  if (!isEthereumAddress(from)) throw new Error("Invalid from address");
+  if (!isEthereumAddress(to)) throw new Error("Invalid to address");
+  const data = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: "transfer",
+    args: [to, BigInt(value)]
+  });
+  return {
+    from,
+    to: token.contractAddress,
+    data
+  };
+};
+
+const SUBSCRIPTION_INTERVAL$4 = 6_000;
+const subscribeBalances$8 = ({
+  networkId,
+  tokensWithAddresses,
+  connector
+}) => {
+  if (!tokensWithAddresses.length) return of({
+    success: [],
+    errors: []
+  });
+  return new Observable(subscriber => {
+    const abortController = new AbortController();
+    const poll = async () => {
+      try {
+        if (abortController.signal.aborted) return;
+        const balances = await fetchBalances$8({
+          networkId,
+          tokensWithAddresses: tokensWithAddresses,
+          connector
+        });
+        if (abortController.signal.aborted) return;
+        subscriber.next(balances);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$4);
+      } catch (error) {
+        log.error("Error", {
+          module: MODULE_TYPE$8,
+          networkId,
+          addressesByToken: tokensWithAddresses,
+          error
+        });
+        subscriber.error(error);
+      }
+    };
+    poll();
+    return () => {
+      abortController.abort();
+    };
+  }).pipe(distinctUntilChanged(isEqual));
+};
+
+const EvmUniswapV2BalanceModule = {
+  type: MODULE_TYPE$8,
+  platform: PLATFORM$8,
+  getMiniMetadata: getMiniMetadata$8,
+  fetchTokens: fetchTokens$8,
+  fetchBalances: fetchBalances$8,
+  subscribeBalances: subscribeBalances$8,
+  getTransferCallData: getTransferCallData$8
+};
+
+// to be used by chaindata too
+const EvmUniswapV2TokenConfigSchema = z.strictObject({
+  contractAddress: EvmUniswapV2TokenSchema.shape.contractAddress,
+  ...TokenConfigBaseSchema.shape
+});
+
+const MODULE_TYPE$7 = SolNativeTokenSchema.shape.type.value;
+const PLATFORM$7 = SolNativeTokenSchema.shape.platform.value;
+
+const fetchBalances$7 = async ({
+  networkId,
+  tokensWithAddresses,
+  connector
+}) => {
+  if (!tokensWithAddresses.length) return {
+    success: [],
+    errors: []
+  };
+  const connection = await connector.getConnection(networkId);
+  if (!connection) throw new Error(`Could not get rpc provider for sol network ${networkId}`);
+  for (const [token, addresses] of tokensWithAddresses) {
+    if (token.type !== MODULE_TYPE$7 || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for balance module: ${token.type} on ${token.networkId}`);
+    for (const address of addresses) if (!isSolanaAddress(address)) throw new Error(`Invalid solana address for balance module: ${address} for token ${token.id}`);
+  }
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
+  const results = await Promise.allSettled(balanceDefs.map(async ({
+    token,
+    address
+  }) => {
+    try {
+      const publicKey = new PublicKey(address);
+      const lamports = await connection.getBalance(publicKey);
+      return {
+        address: address,
+        tokenId: token.id,
+        value: lamports.toString(),
+        source: MODULE_TYPE$7,
+        networkId: token.networkId,
+        status: "live"
+      };
+    } catch (err) {
+      throw new BalanceFetchError(`Failed to get balance for token ${token.id} and address ${address} on chain ${networkId}`, token.id, address, err);
+    }
+  }));
+  return results.reduce((acc, result) => {
+    if (result.status === "fulfilled") acc.success.push(result.value);else {
+      const error = result.reason;
+      acc.errors.push({
+        tokenId: error.tokenId,
+        address: error.address,
+        error
+      });
+    }
+    return acc;
+  }, {
+    success: [],
+    errors: []
+  });
+};
+
+const fetchTokens$7 = async ({
+  networkId,
+  tokens
+}) => {
+  // assume there is one and only one token in the array
+  if (tokens.length !== 1) throw new Error("EVM Native module expects the nativeCurrency to be passed as a single token in the array");
+  const token = assign({
+    id: solNativeTokenId(networkId),
+    type: MODULE_TYPE$7,
+    platform: PLATFORM$7,
+    networkId,
+    isDefault: true
+  }, tokens[0]);
+  const parsed = SolNativeTokenSchema.safeParse(token);
+  if (!parsed.success) {
+    log.warn("Ignoring token with invalid schema", token);
+    return [];
+  }
+  return [parsed.data];
+};
+
+const getMiniMetadata$7 = () => {
+  throw new Error("MiniMetadata is not supported for sol-native tokens");
+};
+
+const getTransferCallData$7 = ({
+  from,
+  to,
+  value,
+  token
+}) => {
+  if (!isTokenOfType(token, MODULE_TYPE$7)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$7}.`);
+  const fromPubkey = new PublicKey(from);
+  const transferIx = SystemProgram.transfer({
+    fromPubkey,
+    toPubkey: new PublicKey(to),
+    lamports: Number(value)
+  });
+  return [transferIx];
+};
+
+const SUBSCRIPTION_INTERVAL$3 = 6_000;
+const subscribeBalances$7 = ({
+  networkId,
+  tokensWithAddresses,
+  connector
+}) => {
+  if (!tokensWithAddresses.length) return of({
+    success: [],
+    errors: []
+  });
+  return new Observable(subscriber => {
+    const abortController = new AbortController();
+    const poll = async () => {
+      try {
+        if (abortController.signal.aborted) return;
+        const balances = await fetchBalances$7({
+          networkId,
+          tokensWithAddresses,
+          connector
+        });
+        if (abortController.signal.aborted) return;
+        subscriber.next(balances);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$3);
+      } catch (error) {
+        log.error("Error", {
+          module: MODULE_TYPE$7,
+          networkId,
+          tokensWithAddresses,
+          error
+        });
+        subscriber.error(error);
+      }
+    };
+    poll();
+    return () => {
+      abortController.abort();
+    };
+  }).pipe(distinctUntilChanged(isEqual));
+};
+
+const SolNativeBalanceModule = {
+  type: MODULE_TYPE$7,
+  platform: PLATFORM$7,
+  getMiniMetadata: getMiniMetadata$7,
+  fetchTokens: fetchTokens$7,
+  fetchBalances: fetchBalances$7,
+  subscribeBalances: subscribeBalances$7,
+  getTransferCallData: getTransferCallData$7
+};
+
+// to be used by chaindata too
+const SolNativeTokenConfigSchema = z.strictObject({
+  ...TokenConfigBaseSchema.shape
+});
+
+const MODULE_TYPE$6 = SolSplTokenSchema.shape.type.value;
+const PLATFORM$6 = SolSplTokenSchema.shape.platform.value;
+
+const fetchRuntimeCallResult = async (connector, networkId, metadataRpc, apiName, method, args) => {
+  const {
+    builder
+  } = parseMetadataRpc(metadataRpc);
+  const call = builder.buildRuntimeCall(apiName, method);
+  const hex = await connector.send(networkId, "state_call", [`${apiName}_${method}`, toHex(call.args.enc(args))]);
+  return call.value.dec(hex);
+};
+
+const hasStorageItem = (metadata, palletName, itemName) => {
+  const pallet = metadata.pallets.find(p => p.name === palletName);
+  if (!pallet || !pallet.storage) return false;
+  return pallet.storage.items.some(item => item.name === itemName);
+};
+const hasStorageItems = (metadata, palletName, itemNames) => {
+  const pallet = metadata.pallets.find(p => p.name === palletName);
+  if (!pallet || !pallet.storage) return false;
+  return itemNames.every(itemName => pallet.storage?.items.some(item => item.name === itemName));
+};
+const hasRuntimeApi = (metadata, apiName, method) => {
+  const api = metadata.apis.find(api => api.name === apiName);
+  if (!api || !api.methods) return false;
+  return api.methods.some(m => m.name === method);
+};
+const getConstantValue = (metadataRpc, pallet, constant) => {
+  const {
+    unifiedMetadata,
+    builder
+  } = parseMetadataRpc(metadataRpc);
+  const codec = builder.buildConstant(pallet, constant);
+  const encodedValue = unifiedMetadata.pallets.find(({
+    name
+  }) => name === pallet)?.constants.find(({
+    name
+  }) => name === constant)?.value;
+  if (!encodedValue) throw new Error(`Constant ${pallet}.${constant} not found`);
+  return codec.dec(encodedValue);
+};
+const tryGetConstantValue = (metadataRpc, pallet, constant) => {
+  const {
+    unifiedMetadata,
+    builder
+  } = parseMetadataRpc(metadataRpc);
+  const encodedValue = unifiedMetadata.pallets.find(({
+    name
+  }) => name === pallet)?.constants.find(({
+    name
+  }) => name === constant)?.value;
+  if (!encodedValue) return null;
+  const codec = builder.buildConstant(pallet, constant);
+  return codec.dec(encodedValue);
+};
+
+const fetchRpcQueryPack = async (connector, networkId, queries) => {
+  const allStateKeys = queries.flatMap(({
+    stateKeys
+  }) => stateKeys).filter(isNotNil);
+
+  // doing a query without keys would throw an error => return early
+  if (!allStateKeys.length) return queries.map(({
+    stateKeys,
+    decodeResult
+  }) => decodeResult(stateKeys.map(() => null)));
+  const [result] = await connector.send(networkId, "state_queryStorageAt", [allStateKeys]);
+  return decodeRpcQueryPack(queries, result);
+};
+const getRpcQueryPack$ = (connector, networkId, queries, timeout = false) => {
+  const allStateKeys = queries.flatMap(({
+    stateKeys
+  }) => stateKeys).filter(isNotNil);
+
+  // doing a query without keys would throw an error => return early
+  if (!allStateKeys.length) return of(queries.map(({
+    stateKeys,
+    decodeResult
+  }) => decodeResult(stateKeys.map(() => null))));
+  return new Observable(subscriber => {
+    // first subscription callback includes results for all state keys, but further callbacks will only include the ones that changed
+    // => we need to keep all results in memory and update them after each callback, so we can emit the full result set each time
+    const changesCache = {};
+    const promUnsub = connector.subscribe(networkId, "state_subscribeStorage", "state_storage", [allStateKeys], (error, result) => {
+      if (error) subscriber.error(error);else if (result) {
+        // update the cache
+        for (const [stateKey, encodedResult] of result.changes) changesCache[stateKey] = encodedResult;
+
+        // regenerate the full changes array
+        const changes = toPairs(changesCache);
+
+        // decode and emit results for all queries
+        subscriber.next(decodeRpcQueryPack(queries, {
+          block: result.block,
+          changes
+        }));
+      }
+    }, timeout);
+    return () => {
+      promUnsub.then(unsub => unsub("state_unsubscribeStorage"));
+    };
+  });
+};
+const decodeRpcQueryPack = (queries, result) => {
+  return queries.reduce((acc, {
+    stateKeys,
+    decodeResult
+  }) => {
+    const changes = stateKeys.map(stateKey => {
+      if (!stateKey || !result) return null;
+      const change = result.changes.find(([key]) => key === stateKey);
+      if (!change) return null;
+      return change[1];
+    });
+    acc.push(decodeResult(changes));
+    return acc;
+  }, []);
+};
+
+const buildNetworkStorageCoders = (chainId, miniMetadata, coders) => {
+  if (!miniMetadata.data) return null;
+  const metadata = unifyMetadata(decAnyMetadata(miniMetadata.data));
+  try {
+    const scaleBuilder = getDynamicBuilder(getLookupFn(metadata));
+    const builtCoders = Object.fromEntries(Object.entries(coders).flatMap(([key, moduleMethodOrFn]) => {
+      const [module, method] = typeof moduleMethodOrFn === "function" ? moduleMethodOrFn({
+        chainId
+      }) : moduleMethodOrFn;
+      try {
+        return [[key, scaleBuilder.buildStorage(module, method)]];
+      } catch (cause) {
+        log.trace(`Failed to build SCALE coder for chain ${chainId} (${module}::${method})`, cause);
+        return [];
+      }
+    }));
+    return builtCoders;
+  } catch (cause) {
+    log.error(`Failed to build SCALE coders for chain ${chainId} (${JSON.stringify(coders)})`, cause);
+  }
+  return null;
+};
+
+const SPL_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+const fetchBalances$6 = async ({
+  networkId,
+  tokensWithAddresses,
+  connector
+}) => {
+  if (!tokensWithAddresses.length) return {
+    success: [],
+    errors: []
+  };
+  const connection = await connector.getConnection(networkId);
+  if (!connection) throw new Error(`Could not get connection for Solana network ${networkId}`);
+  const accountAddresses = uniq(tokensWithAddresses.flatMap(([, addresses]) => addresses));
+  const balancesPerAddress = await Promise.all(accountAddresses.map(async address => {
+    const tokenAccounts = await connection.getParsedTokenAccountsByOwner(new PublicKey(address), {
+      programId: new PublicKey(SPL_PROGRAM_ID) // SPL Token Program ID
+    });
+    const balances = tokenAccounts.value.map(d => {
+      try {
+        const mintAddress = d.account.data.parsed.info.mint;
+        const value = d.account.data.parsed.info.tokenAmount.amount ?? "0";
+        return {
+          tokenId: solSplTokenId(networkId, mintAddress),
+          networkId,
+          address,
+          source: MODULE_TYPE$6,
+          status: "live",
+          value
+        };
+      } catch (err) {
+        log.warn("Failed to parse token amount", {
+          address,
+          d
+        });
+        return null;
+      }
+    }).filter(isNotNil);
+    return [address, balances];
+  }));
+  const allBalancesByKey = keyBy(balancesPerAddress.flatMap(([, addressBalances]) => addressBalances), b => getBalanceKey(b.tokenId, b.address));
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
+
+  // return a balance entry for all token/address pairs that were requested
+  const success = balanceDefs.map(bd => {
+    const found = allBalancesByKey[getBalanceKey(bd.token.id, bd.address)];
+    return found ?? {
+      tokenId: bd.token.id,
+      networkId: bd.token.networkId,
+      address: bd.address,
+      source: MODULE_TYPE$6,
+      status: "live",
+      value: "0"
+    };
+  });
+
+  // return only the balances that match the tokens we are interested in
+  return {
+    success,
+    errors: []
+  }; // TODO output errors if any
+};
+const getBalanceKey = (tokenId, address) => `${tokenId}:${address}`;
+
+const TokenCacheSchema = z.discriminatedUnion("isValid", [z.strictObject({
+  id: SolSplTokenSchema.shape.id,
+  isValid: z.literal(true),
+  ...SolSplTokenSchema.pick({
+    symbol: true,
+    decimals: true,
+    name: true,
+    logo: true
+  }).shape
+}), z.strictObject({
+  id: SolSplTokenSchema.shape.id,
+  isValid: z.literal(false)
+})]);
+const METAPLEX_PROGRAM_ID = new PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+const fetchTokens$6 = async ({
+  networkId,
+  tokens,
+  connector,
+  cache
+}) => {
+  const result = [];
+  for (const tokenConfig of tokens) {
+    const tokenId = solSplTokenId(networkId, tokenConfig.mintAddress);
+    let cached = cache[tokenId] && TokenCacheSchema.safeParse(cache[tokenId]).data;
+    if (!cached) {
+      const tokenInfo = await fetchOnChainTokenData(connector, tokenId);
+      if (tokenInfo) cache[tokenId] = tokenInfo;
+    }
+    cached = cache[tokenId] && TokenCacheSchema.safeParse(cache[tokenId]).data;
+    if (cached?.isValid === false) continue;
     const base = {
       id: tokenId,
       type: MODULE_TYPE$6,
       platform: PLATFORM$6,
       networkId
     };
-    const cached2 = cache[tokenId] && TokenCacheSchema.safeParse(cache[tokenId]).data;
-    if (cached2?.isValid === false) continue;
-    const token = assign(base, cached2?.isValid ? omit(cached2, ["isValid"]) : {}, tokenConfig);
-    const parsed = EvmUniswapV2TokenSchema.safeParse(token);
+    const token = assign(base, cached?.isValid ? omit(cached, ["isValid"]) : {}, tokenConfig);
+    const parsed = SolSplTokenSchema.safeParse(token);
     if (!parsed.success) {
-      log.warn("Ignoring token with invalid schema", token);
+      log.warn("Ignoring token with invalid SolSplTokenSchema", {
+        token
+      });
       continue;
     }
     result.push(parsed.data);
   }
   return result;
 };
+const ERROR_NO_MINT = "No mint info available";
+const ERROR_NO_METADATA = "No metadata account found";
+const ERROR_INVALID_DATA = "Invalid on-chain data";
+const fetchOnChainTokenData = async (connector, tokenId) => {
+  try {
+    const {
+      networkId,
+      mintAddress
+    } = parseSolSplTokenId(tokenId);
+    const connection = await connector.getConnection(networkId);
+    if (!connection) {
+      log.warn(`No connection found for network ${networkId}`);
+      return null;
+    }
+    const mintPubKey = new PublicKey(mintAddress);
+    const mintInfo = await connection.getAccountInfo(mintPubKey);
+    if (!mintInfo?.data) throw new Error(ERROR_NO_MINT);
+    const mint = MintLayout.decode(mintInfo.data);
+    const [metadataPDA] = PublicKey.findProgramAddressSync([Buffer.from("metadata"), METAPLEX_PROGRAM_ID.toBuffer(), mintPubKey.toBuffer()], METAPLEX_PROGRAM_ID);
+
+    // 3. Fetch metadata account directly (traditional way)
+    const metadataAccount = await connection.getAccountInfo(new PublicKey(metadataPDA));
+    if (!metadataAccount) throw new Error(ERROR_NO_METADATA);
+    const metadata = deserializeMetadata({
+      publicKey: publicKey(metadataPDA),
+      executable: metadataAccount.executable,
+      owner: publicKey(metadataAccount.owner),
+      lamports: sol(metadataAccount.lamports),
+      data: metadataAccount.data
+    });
+    const parsed = TokenCacheSchema.safeParse({
+      id: tokenId,
+      symbol: metadata.symbol.trim(),
+      name: metadata.name.trim(),
+      decimals: mint.decimals,
+      isValid: true
+    });
+    if (!parsed.success) throw new Error(ERROR_INVALID_DATA);
+    return parsed.data;
+  } catch (err) {
+    const msg = err.message;
+    if ([ERROR_NO_MINT, ERROR_NO_METADATA, ERROR_INVALID_DATA].includes(msg)) return TokenCacheSchema.parse({
+      id: tokenId,
+      isValid: false
+    });
+    log.warn("Failed to fetch sol-spl token data for %s", tokenId, {
+      err
+    });
+  }
+  return null;
+};
 
 const getMiniMetadata$6 = () => {
-  throw new Error("MiniMetadata is not supported for ethereum tokens");
+  throw new Error("MiniMetadata is not supported for solana tokens");
 };
 
-const getTransferCallData$6 = ({
+const getTransferCallData$6 = async ({
   from,
   to,
   value,
-  token
+  token,
+  connector
 }) => {
   if (!isTokenOfType(token, MODULE_TYPE$6)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$6}.`);
-  if (!isEthereumAddress(from)) throw new Error("Invalid from address");
-  if (!isEthereumAddress(to)) throw new Error("Invalid to address");
-  const data = encodeFunctionData({
-    abi: erc20Abi,
-    functionName: "transfer",
-    args: [to, BigInt(value)]
-  });
-  return {
-    from,
-    to: token.contractAddress,
-    data
-  };
+  const connection = await connector.getConnection(token.networkId);
+  const instructions = [];
+  const mint = new PublicKey(token.mintAddress);
+  const fromWallet = new PublicKey(from);
+  const toWallet = new PublicKey(to);
+
+  // Get associated token accounts
+  const fromTokenAccount = await getAssociatedTokenAddress(mint, fromWallet);
+  const toTokenAccount = await getAssociatedTokenAddress(mint, toWallet);
+
+  // Create the target token account if it doesn't exist
+  if (!(await tokenAccountExists(connection, toTokenAccount))) {
+    instructions.push(createAssociatedTokenAccountInstruction(fromWallet,
+    // funder
+    toTokenAccount, toWallet, mint));
+  }
+
+  // Transfer the tokens
+  instructions.push(createTransferInstruction(fromTokenAccount, toTokenAccount, fromWallet, BigInt(value), [], TOKEN_PROGRAM_ID));
+  return instructions;
+};
+const tokenAccountExists = async (connection, address) => {
+  try {
+    await getAccount(connection, address);
+    return true;
+  } catch {
+    return false;
+  }
 };
 
 const SUBSCRIPTION_INTERVAL$2 = 6_000;
@@ -1450,7 +2008,7 @@ const subscribeBalances$6 = ({
   }).pipe(distinctUntilChanged(isEqual));
 };
 
-const EvmUniswapV2BalanceModule = {
+const SolSplBalanceModule = {
   type: MODULE_TYPE$6,
   platform: PLATFORM$6,
   getMiniMetadata: getMiniMetadata$6,
@@ -1461,153 +2019,14 @@ const EvmUniswapV2BalanceModule = {
 };
 
 // to be used by chaindata too
-const EvmUniswapV2TokenConfigSchema = z.strictObject({
-  contractAddress: EvmUniswapV2TokenSchema.shape.contractAddress,
+const SolSplTokenConfigSchema = z.strictObject({
+  mintAddress: SolSplTokenSchema.shape.mintAddress,
   ...TokenConfigBaseSchema.shape
 });
 
 const MODULE_TYPE$5 = SubAssetsTokenSchema.shape.type.value;
 const PLATFORM$5 = SubAssetsTokenSchema.shape.platform.value;
 
-const fetchRpcQueryPack = async (connector, networkId, queries) => {
-  const allStateKeys = queries.flatMap(({
-    stateKeys
-  }) => stateKeys).filter(isNotNil);
-
-  // doing a query without keys would throw an error => return early
-  if (!allStateKeys.length) return queries.map(({
-    stateKeys,
-    decodeResult
-  }) => decodeResult(stateKeys.map(() => null)));
-  const [result] = await connector.send(networkId, "state_queryStorageAt", [allStateKeys]);
-  return decodeRpcQueryPack(queries, result);
-};
-const getRpcQueryPack$ = (connector, networkId, queries, timeout = false) => {
-  const allStateKeys = queries.flatMap(({
-    stateKeys
-  }) => stateKeys).filter(isNotNil);
-
-  // doing a query without keys would throw an error => return early
-  if (!allStateKeys.length) return of(queries.map(({
-    stateKeys,
-    decodeResult
-  }) => decodeResult(stateKeys.map(() => null))));
-  return new Observable(subscriber => {
-    // first subscription callback includes results for all state keys, but further callbacks will only include the ones that changed
-    // => we need to keep all results in memory and update them after each callback, so we can emit the full result set each time
-    const changesCache = {};
-    const promUnsub = connector.subscribe(networkId, "state_subscribeStorage", "state_storage", [allStateKeys], (error, result) => {
-      if (error) subscriber.error(error);else if (result) {
-        // update the cache
-        for (const [stateKey, encodedResult] of result.changes) changesCache[stateKey] = encodedResult;
-
-        // regenerate the full changes array
-        const changes = toPairs(changesCache);
-
-        // decode and emit results for all queries
-        subscriber.next(decodeRpcQueryPack(queries, {
-          block: result.block,
-          changes
-        }));
-      }
-    }, timeout);
-    return () => {
-      promUnsub.then(unsub => unsub("state_unsubscribeStorage"));
-    };
-  });
-};
-const decodeRpcQueryPack = (queries, result) => {
-  return queries.reduce((acc, {
-    stateKeys,
-    decodeResult
-  }) => {
-    const changes = stateKeys.map(stateKey => {
-      if (!stateKey || !result) return null;
-      const change = result.changes.find(([key]) => key === stateKey);
-      if (!change) return null;
-      return change[1];
-    });
-    acc.push(decodeResult(changes));
-    return acc;
-  }, []);
-};
-
-const fetchRuntimeCallResult = async (connector, networkId, metadataRpc, apiName, method, args) => {
-  const {
-    builder
-  } = parseMetadataRpc(metadataRpc);
-  const call = builder.buildRuntimeCall(apiName, method);
-  const hex = await connector.send(networkId, "state_call", [`${apiName}_${method}`, toHex(call.args.enc(args))]);
-  return call.value.dec(hex);
-};
-
-const hasStorageItem = (metadata, palletName, itemName) => {
-  const pallet = metadata.pallets.find(p => p.name === palletName);
-  if (!pallet || !pallet.storage) return false;
-  return pallet.storage.items.some(item => item.name === itemName);
-};
-const hasStorageItems = (metadata, palletName, itemNames) => {
-  const pallet = metadata.pallets.find(p => p.name === palletName);
-  if (!pallet || !pallet.storage) return false;
-  return itemNames.every(itemName => pallet.storage?.items.some(item => item.name === itemName));
-};
-const hasRuntimeApi = (metadata, apiName, method) => {
-  const api = metadata.apis.find(api => api.name === apiName);
-  if (!api || !api.methods) return false;
-  return api.methods.some(m => m.name === method);
-};
-const getConstantValue = (metadataRpc, pallet, constant) => {
-  const {
-    unifiedMetadata,
-    builder
-  } = parseMetadataRpc(metadataRpc);
-  const codec = builder.buildConstant(pallet, constant);
-  const encodedValue = unifiedMetadata.pallets.find(({
-    name
-  }) => name === pallet)?.constants.find(({
-    name
-  }) => name === constant)?.value;
-  if (!encodedValue) throw new Error(`Constant ${pallet}.${constant} not found`);
-  return codec.dec(encodedValue);
-};
-const tryGetConstantValue = (metadataRpc, pallet, constant) => {
-  const {
-    unifiedMetadata,
-    builder
-  } = parseMetadataRpc(metadataRpc);
-  const encodedValue = unifiedMetadata.pallets.find(({
-    name
-  }) => name === pallet)?.constants.find(({
-    name
-  }) => name === constant)?.value;
-  if (!encodedValue) return null;
-  const codec = builder.buildConstant(pallet, constant);
-  return codec.dec(encodedValue);
-};
-
-const buildNetworkStorageCoders = (chainId, miniMetadata, coders) => {
-  if (!miniMetadata.data) return null;
-  const metadata = unifyMetadata(decAnyMetadata(miniMetadata.data));
-  try {
-    const scaleBuilder = getDynamicBuilder(getLookupFn(metadata));
-    const builtCoders = Object.fromEntries(Object.entries(coders).flatMap(([key, moduleMethodOrFn]) => {
-      const [module, method] = typeof moduleMethodOrFn === "function" ? moduleMethodOrFn({
-        chainId
-      }) : moduleMethodOrFn;
-      try {
-        return [[key, scaleBuilder.buildStorage(module, method)]];
-      } catch (cause) {
-        log.trace(`Failed to build SCALE coder for chain ${chainId} (${module}::${method})`, cause);
-        return [];
-      }
-    }));
-    return builtCoders;
-  } catch (cause) {
-    log.error(`Failed to build SCALE coders for chain ${chainId} (${JSON.stringify(coders)})`, cause);
-  }
-  return null;
-};
-
 const buildQueries$2 = (networkId, balanceDefs, miniMetadata) => {
   const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
     storage: ["Assets", "Account"]
@@ -1843,11 +2262,6 @@ function includeInTotalExtraAmount(extra) {
   return extra.filter(extra => extra.includeInTotal).map(extra => extra.amount.planck).reduce((a, b) => a + b, 0n);
 }
 
-/**
- * Have the importing library define its Token and BalanceJson enums (as a sum type of all plugins) and pass them into some
- * internal global typescript context, which is then picked up on by this module.
- */
-
 /** A utility type used to extract the underlying `BalanceType` of a specific source from a generalised `BalanceJson` */
 
 /** TODO: Remove this in favour of a frontend-friendly `ChaindataProvider` */
@@ -2584,8 +2998,6 @@ const getValueId = amount => {
 
 /** A labelled extra amount of a balance */
 
-/** Used by plugins to help define their custom `BalanceType` */
-
 /** For fast db access, you can calculate the primary key for a miniMetadata using this method */
 const deriveMiniMetadataId = ({
   source,
@@ -6142,7 +6554,7 @@ const SubTokensMiniMetadataExtraSchema = z.strictObject({
   palletId: z.string()
 });
 
-const BALANCE_MODULES = [SubNativeBalanceModule, SubAssetsBalanceModule, SubHydrationBalanceModule, SubForeignAssetsBalanceModule, SubPsp22BalanceModule, SubTokensBalanceModule, EvmErc20BalanceModule, EvmUniswapV2BalanceModule, EvmNativeBalanceModule];
+const BALANCE_MODULES = [SubNativeBalanceModule, SubAssetsBalanceModule, SubHydrationBalanceModule, SubForeignAssetsBalanceModule, SubPsp22BalanceModule, SubTokensBalanceModule, EvmErc20BalanceModule, EvmUniswapV2BalanceModule, EvmNativeBalanceModule, SolNativeBalanceModule, SolSplBalanceModule];
 
 // share requests as all modules will call this at once
 const CACHE$1 = new Map();
@@ -6320,10 +6732,25 @@ class BalancesProvider {
             {
               return this.getEthereumNetworkModuleBalances$(networkId, tokensWithAddresses, mod);
             }
+          case "solana":
+            {
+              return this.getSolanaNetworkModuleBalances$(networkId, tokensWithAddresses, mod);
+            }
           case "polkadot":
             {
               return this.getPolkadotNetworkModuleBalances$(networkId, tokensWithAddresses, mod);
             }
+          default:
+            {
+              log.warn("[balances] Unsupported network platform for module", {
+                networkId,
+                mod
+              });
+              return of({
+                status: "live",
+                balances: []
+              });
+            }
         }
       }));
     }), map(results => {
@@ -6353,7 +6780,7 @@ class BalancesProvider {
         address
       })));
       if (!this.#chainConnectors.substrate) {
-        log.debug("[balances] no substrate connector or miniMetadata for module", mod.type);
+        log.warn("[balances] no substrate connector or miniMetadata for module", mod.type);
         return defer(() => of({
           status: "initialising",
           balances: this.getStoredBalances(moduleAddressesByTokenId)
@@ -6404,7 +6831,7 @@ class BalancesProvider {
         address
       })));
       if (!this.#chainConnectors.evm) {
-        log.debug("[balances] no ethereum connector for module", mod.type);
+        log.warn("[balances] no ethereum connector for module", mod.type);
         return defer(() => of({
           status: "initialising",
           balances: this.getStoredBalances(moduleAddressesByTokenId)
@@ -6436,6 +6863,56 @@ class BalancesProvider {
       })));
     });
   }
+  getSolanaNetworkModuleBalances$(networkId, tokensWithAddresses, mod) {
+    return getSharedObservable(`BalancesProvider.getSolanaNetworkModuleBalances$`, {
+      networkId,
+      mod,
+      tokensWithAddresses
+    }, () => {
+      if (!tokensWithAddresses.length) return of({
+        status: "live",
+        balances: []
+      });
+      const moduleAddressesByTokenId = fromPairs(tokensWithAddresses.map(([token, addresses]) => [token.id, addresses]));
+
+      // all balance ids expected in result set
+      const balanceIds = toPairs(moduleAddressesByTokenId).flatMap(([tokenId, addresses]) => addresses.map(address => getBalanceId({
+        tokenId,
+        address
+      })));
+      if (!this.#chainConnectors.solana) {
+        log.warn("[balances] no solana connector for module", mod.type);
+        return defer(() => of({
+          status: "initialising",
+          balances: this.getStoredBalances(moduleAddressesByTokenId)
+        }));
+      }
+      const moduleBalances$ = mod.subscribeBalances({
+        networkId,
+        tokensWithAddresses,
+        connector: this.#chainConnectors.solana
+      }).pipe(catchError(() => EMPTY),
+      // don't emit, let provider mark balances stale
+      map(results => ({
+        status: "live",
+        // exclude zero balances
+        balances: results.success.filter(b => new Balance(b).total.planck > 0n)
+      })), tap(results => {
+        this.updateStorage$(balanceIds, results);
+      }),
+      // shareReplay + keepAlive(0) keep the subscription alive while root observable is being unsubscribed+resubscribed, in case any input change
+      shareReplay({
+        refCount: true,
+        bufferSize: 1
+      }), keepAlive(0));
+
+      // defer the startWith call to start with up to date balances each time the observable is re-subscribed to
+      return defer(() => moduleBalances$.pipe(startWith({
+        status: "initialising",
+        balances: this.getStoredBalances(moduleAddressesByTokenId)
+      })));
+    });
+  }
   updateStorage$(balanceIds, balancesResult) {
     if (balancesResult.status !== "live") return;
     const storage = this.#storage.getValue();
@@ -6546,18 +7023,42 @@ class BalancesProvider {
     }));
   }
 }
-const isAddressCompatibleWithNetwork = (network, address) => {
+const isAccountPlatformCompatibleWithNetwork = (network, platform) => {
   switch (network.platform) {
     case "ethereum":
-      return isEthereumAddress(address);
+      return platform === "ethereum";
+    case "solana":
+      return platform === "solana";
     case "polkadot":
-      return isEthereumAddress(address) ? network.account === "secp256k1" : network.account !== "secp256k1";
+      {
+        switch (network.account) {
+          case "secp256k1":
+            return platform === "ethereum";
+          case "*25519":
+            return platform === "polkadot";
+          default:
+            throw new Error(`Unsupported polkadot network account type ${network.account}`);
+        }
+      }
     default:
       log.warn("Unsupported network platform", network);
       throw new Error("Unsupported network platform");
   }
 };
+
+/**
+ * If this is the address of an account, use isAccountCompatibleWithChain instead.
+ * Otherwise it could lead to a loss of funds
+ * @param chain
+ * @param address
+ * @returns
+ */
+const isAddressCompatibleWithNetwork = (network, address) => {
+  // TODO try with return true to check if wallet filters correctly upfront
+  const accountPlatform = getAccountPlatformFromAddress(address);
+  return isAccountPlatformCompatibleWithNetwork(network, accountPlatform);
+};
 const sortByBalanceId = (a, b) => getBalanceId(a).localeCompare(getBalanceId(b));
 const sortByMiniMetadataId = (a, b) => a.id.localeCompare(b.id);
 
-export { BALANCE_MODULES, Balance, BalanceFormatter, BalanceValueGetter, Balances, BalancesProvider, Change24hCurrencyFormatter, EvmErc20BalanceModule, EvmErc20TokenConfigSchema, EvmNativeBalanceModule, EvmNativeTokenConfigSchema, EvmUniswapV2BalanceModule, EvmUniswapV2TokenConfigSchema, FiatSumBalancesFormatter, ONE_ALPHA_TOKEN, PlanckSumBalancesFormatter, SCALE_FACTOR, SUBTENSOR_MIN_STAKE_AMOUNT_PLANK, SUBTENSOR_ROOT_NETUID, SubAssetsBalanceModule, SubAssetsTokenConfigSchema, SubForeignAssetsBalanceModule, SubForeignAssetsTokenConfigSchema, SubHydrationBalanceModule, SubHydrationTokenConfigSchema, SubNativeBalanceModule, SubNativeMiniMetadataExtraSchema, SubNativeModuleConfigSchema, SubNativeTokenConfigSchema, SubPsp22BalanceModule, SubPsp22TokenConfigSchema, SubTokensBalanceModule, SubTokensMiniMetadataExtraSchema, SubTokensModuleConfigSchema, SubTokensTokenConfigSchema, SumBalancesFormatter, abiMulticall, calculateAlphaPrice, calculateTaoAmountFromAlpha, calculateTaoFromDynamicInfo, deriveMiniMetadataId, erc20BalancesAggregatorAbi, excludeFromFeePayableLocks, excludeFromTransferableAmount, filterBaseLocks, filterMirrorTokens, getBalanceId, getLockTitle, getLockedType, getValueId, includeInTotalExtraAmount, uniswapV2PairAbi };
+export { BALANCE_MODULES, Balance, BalanceFormatter, BalanceValueGetter, Balances, BalancesProvider, Change24hCurrencyFormatter, EvmErc20BalanceModule, EvmErc20TokenConfigSchema, EvmNativeBalanceModule, EvmNativeTokenConfigSchema, EvmUniswapV2BalanceModule, EvmUniswapV2TokenConfigSchema, FiatSumBalancesFormatter, ONE_ALPHA_TOKEN, PlanckSumBalancesFormatter, SCALE_FACTOR, SUBTENSOR_MIN_STAKE_AMOUNT_PLANK, SUBTENSOR_ROOT_NETUID, SolNativeBalanceModule, SolNativeTokenConfigSchema, SolSplBalanceModule, SolSplTokenConfigSchema, SubAssetsBalanceModule, SubAssetsTokenConfigSchema, SubForeignAssetsBalanceModule, SubForeignAssetsTokenConfigSchema, SubHydrationBalanceModule, SubHydrationTokenConfigSchema, SubNativeBalanceModule, SubNativeMiniMetadataExtraSchema, SubNativeModuleConfigSchema, SubNativeTokenConfigSchema, SubPsp22BalanceModule, SubPsp22TokenConfigSchema, SubTokensBalanceModule, SubTokensMiniMetadataExtraSchema, SubTokensModuleConfigSchema, SubTokensTokenConfigSchema, SumBalancesFormatter, abiMulticall, calculateAlphaPrice, calculateTaoAmountFromAlpha, calculateTaoFromDynamicInfo, deriveMiniMetadataId, erc20BalancesAggregatorAbi, excludeFromFeePayableLocks, excludeFromTransferableAmount, filterBaseLocks, filterMirrorTokens, getBalanceId, getLockTitle, getLockedType, getValueId, includeInTotalExtraAmount, uniswapV2PairAbi };