@talismn/balances 1.3.6 → 1.4.0

package/dist/index.js

@@ -45,12 +45,14 @@ __export(index_exports, {
   EvmUniswapV2BalanceModule: () => EvmUniswapV2BalanceModule,
   EvmUniswapV2TokenConfigSchema: () => EvmUniswapV2TokenConfigSchema,
   FiatSumBalancesFormatter: () => FiatSumBalancesFormatter,
-  MINIMETADATA_VERSION: () => import_chaindata_provider65.MINIMETADATA_VERSION,
+  MINIMETADATA_VERSION: () => import_chaindata_provider72.MINIMETADATA_VERSION,
   PlanckSumBalancesFormatter: () => PlanckSumBalancesFormatter,
   SolNativeBalanceModule: () => SolNativeBalanceModule,
   SolNativeTokenConfigSchema: () => SolNativeTokenConfigSchema,
   SolSplBalanceModule: () => SolSplBalanceModule,
   SolSplTokenConfigSchema: () => SolSplTokenConfigSchema,
+  SolToken2022BalanceModule: () => SolToken2022BalanceModule,
+  SolToken2022TokenConfigSchema: () => SolToken2022TokenConfigSchema,
   SubAssetsBalanceModule: () => SubAssetsBalanceModule,
   SubAssetsTokenConfigSchema: () => SubAssetsTokenConfigSchema,
   SubDTaoBalanceModule: () => SubDTaoBalanceModule,
@@ -92,11 +94,11 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/BalancesProvider.ts
-var import_chaindata_provider64 = require("@talismn/chaindata-provider");
+var import_chaindata_provider71 = require("@talismn/chaindata-provider");
 var import_crypto8 = require("@talismn/crypto");
-var import_util16 = require("@talismn/util");
-var import_lodash_es27 = require("lodash-es");
-var import_rxjs15 = require("rxjs");
+var import_util15 = require("@talismn/util");
+var import_lodash_es30 = require("lodash-es");
+var import_rxjs16 = require("rxjs");
 var import_viem9 = require("viem");
 
 // src/getMiniMetadatas/index.ts
@@ -108,7 +110,7 @@ var import_anylogger = __toESM(require("anylogger"));
 // package.json
 var package_default = {
   name: "@talismn/balances",
-  version: "1.3.6",
+  version: "1.4.0",
   author: "Talisman",
   homepage: "https://talisman.xyz",
   license: "GPL-3.0-or-later",
@@ -160,7 +162,6 @@ var package_default = {
   devDependencies: {
     "@polkadot/api-contract": "16.1.2",
     "@polkadot/types": "16.1.2",
-    "@polkadot/util": "13.5.3",
     "@talismn/tsconfig": "workspace:*",
     "@types/lodash-es": "4.17.12",
     typescript: "^5.6.3"
@@ -168,8 +169,6 @@ var package_default = {
   peerDependencies: {
     "@polkadot/api-contract": "*",
     "@polkadot/types": "*",
-    "@polkadot/util": "*",
-    "@polkadot/util-crypto": "*",
     "@substrate/txwrapper-core": "*"
   },
   types: "./dist/index.d.ts",
@@ -1901,8 +1900,8 @@ var fetchBalances4 = async ({
   const results = await Promise.allSettled(
     balanceDefs.map(async ({ token, address }) => {
       try {
-        const publicKey2 = new import_web3.PublicKey(address);
-        const lamports = await connection.getBalance(publicKey2);
+        const publicKey3 = new import_web3.PublicKey(address);
+        const lamports = await connection.getBalance(publicKey3);
         return {
           address,
           tokenId: token.id,
@@ -2055,8 +2054,8 @@ var MODULE_TYPE5 = import_chaindata_provider19.SolSplTokenSchema.shape.type.valu
 var PLATFORM5 = import_chaindata_provider19.SolSplTokenSchema.shape.platform.value;
 
 // src/modules/sol-spl/fetchBalances.ts
-var import_web33 = require("@solana/web3.js");
-var import_chaindata_provider21 = require("@talismn/chaindata-provider");
+var import_web34 = require("@solana/web3.js");
+var import_chaindata_provider22 = require("@talismn/chaindata-provider");
 var import_util2 = require("@talismn/util");
 var import_lodash_es12 = require("lodash-es");
 
@@ -2213,8 +2212,77 @@ var getDetectedTokensIds$ = (address) => tokenIdsByAddress.pipe(
   (0, import_rxjs6.distinctUntilChanged)(import_lodash_es11.isEqual)
 );
 
+// src/modules/sol-spl/onChainTokenMetadata.ts
+var import_mpl_token_metadata = require("@metaplex-foundation/mpl-token-metadata");
+var import_umi = require("@metaplex-foundation/umi");
+var import_spl_token = require("@solana/spl-token");
+var import_web33 = require("@solana/web3.js");
+var import_chaindata_provider21 = require("@talismn/chaindata-provider");
+var import_v47 = __toESM(require("zod/v4"));
+var TokenCacheSchema3 = import_v47.default.discriminatedUnion("isValid", [
+  import_v47.default.strictObject({
+    id: import_chaindata_provider21.SolSplTokenSchema.shape.id,
+    isValid: import_v47.default.literal(true),
+    ...import_chaindata_provider21.SolSplTokenSchema.pick({ symbol: true, decimals: true, name: true, logo: true }).shape
+  }),
+  import_v47.default.strictObject({
+    id: import_chaindata_provider21.SolSplTokenSchema.shape.id,
+    isValid: import_v47.default.literal(false)
+  })
+]);
+var METAPLEX_PROGRAM_ID = new import_web33.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+var ERROR_NO_MINT = "No mint info available";
+var ERROR_NO_METADATA = "No metadata account found";
+var ERROR_INVALID_DATA = "Invalid on-chain data";
+var fetchOnChainTokenData = async (connector, tokenId) => {
+  try {
+    const { networkId, mintAddress } = (0, import_chaindata_provider21.parseSolSplTokenId)(tokenId);
+    const connection = await connector.getConnection(networkId);
+    if (!connection) {
+      log_default.warn(`No connection found for network ${networkId}`);
+      return null;
+    }
+    const mintPubKey = new import_web33.PublicKey(mintAddress);
+    const mintInfo = await connection.getAccountInfo(mintPubKey);
+    if (!mintInfo?.data) throw new Error(ERROR_NO_MINT);
+    const mint = import_spl_token.MintLayout.decode(mintInfo.data);
+    const [metadataPDA] = import_web33.PublicKey.findProgramAddressSync(
+      [Buffer.from("metadata"), METAPLEX_PROGRAM_ID.toBuffer(), mintPubKey.toBuffer()],
+      METAPLEX_PROGRAM_ID
+    );
+    const metadataAccount = await connection.getAccountInfo(new import_web33.PublicKey(metadataPDA));
+    if (!metadataAccount) throw new Error(ERROR_NO_METADATA);
+    const metadata = (0, import_mpl_token_metadata.deserializeMetadata)({
+      publicKey: (0, import_umi.publicKey)(metadataPDA),
+      executable: metadataAccount.executable,
+      owner: (0, import_umi.publicKey)(metadataAccount.owner),
+      lamports: (0, import_umi.sol)(metadataAccount.lamports),
+      data: metadataAccount.data
+    });
+    const parsed = TokenCacheSchema3.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 TokenCacheSchema3.parse({
+        id: tokenId,
+        isValid: false
+      });
+    log_default.warn("Failed to fetch sol-spl token data for %s", tokenId, { err });
+  }
+  return null;
+};
+
 // src/modules/sol-spl/fetchBalances.ts
 var SPL_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+var dynamicTokenMetadataCache = /* @__PURE__ */ new Map();
 var fetchBalances5 = async ({
   networkId,
   tokensWithAddresses,
@@ -2224,18 +2292,22 @@ var fetchBalances5 = async ({
   const connection = await connector.getConnection(networkId);
   if (!connection) throw new Error(`Could not get connection for Solana network ${networkId}`);
   const accountAddresses = (0, import_lodash_es12.uniq)(tokensWithAddresses.flatMap(([, addresses]) => addresses));
+  const knownTokenIds = new Set(tokensWithAddresses.map(([token]) => token.id));
+  const unknownMints = /* @__PURE__ */ new Set();
   const balancesPerAddress = await Promise.all(
     accountAddresses.map(async (address) => {
-      const tokenAccounts = await connection.getParsedTokenAccountsByOwner(new import_web33.PublicKey(address), {
-        programId: new import_web33.PublicKey(SPL_PROGRAM_ID)
+      const tokenAccounts = await connection.getParsedTokenAccountsByOwner(new import_web34.PublicKey(address), {
+        programId: new import_web34.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";
+          const tokenId = (0, import_chaindata_provider22.solSplTokenId)(networkId, mintAddress);
+          if (!knownTokenIds.has(tokenId) && value !== "0") unknownMints.add(mintAddress);
           return {
-            tokenId: (0, import_chaindata_provider21.solSplTokenId)(networkId, mintAddress),
+            tokenId,
             networkId,
             address,
             source: MODULE_TYPE5,
@@ -2258,6 +2330,42 @@ var fetchBalances5 = async ({
       return [address, balances];
     })
   );
+  const dynamicTokens = [];
+  if (unknownMints.size) {
+    await Promise.all(
+      Array.from(unknownMints).map(async (mintAddress) => {
+        const tokenId = (0, import_chaindata_provider22.solSplTokenId)(networkId, mintAddress);
+        let cached = dynamicTokenMetadataCache.get(tokenId);
+        if (!cached) {
+          const fetched = await fetchOnChainTokenData(connector, tokenId);
+          if (fetched) {
+            dynamicTokenMetadataCache.set(tokenId, fetched);
+            cached = fetched;
+          }
+        }
+        if (!cached || !cached.isValid) return;
+        const token = {
+          id: tokenId,
+          type: MODULE_TYPE5,
+          platform: PLATFORM5,
+          networkId,
+          mintAddress,
+          isDefault: true,
+          symbol: cached.symbol,
+          decimals: cached.decimals,
+          ...cached.name !== void 0 ? { name: cached.name } : {},
+          ...cached.logo !== void 0 ? { logo: cached.logo } : {}
+        };
+        const parsed = import_chaindata_provider22.SolSplTokenSchema.safeParse(token);
+        if (!parsed.success) {
+          log_default.warn("Ignoring dynamic sol-spl token with invalid schema", { token });
+          return;
+        }
+        dynamicTokens.push(parsed.data);
+      })
+    );
+  }
+  const registeredDynamicIds = new Set(dynamicTokens.map((t) => t.id));
   const allBalancesByKey = (0, import_lodash_es12.keyBy)(
     balancesPerAddress.flatMap(([, addressBalances]) => addressBalances),
     (b) => getBalanceKey(b.tokenId, b.address)
@@ -2274,30 +2382,16 @@ var fetchBalances5 = async ({
       value: "0"
     };
   });
-  return { success, errors: [] };
+  for (const balance of balancesPerAddress.flatMap(([, addressBalances]) => addressBalances)) {
+    if (registeredDynamicIds.has(balance.tokenId)) success.push(balance);
+  }
+  return { success, errors: [], dynamicTokens };
 };
 var getBalanceKey = (tokenId, address) => `${tokenId}:${address}`;
 
 // src/modules/sol-spl/fetchTokens.ts
-var import_mpl_token_metadata = require("@metaplex-foundation/mpl-token-metadata");
-var import_umi = require("@metaplex-foundation/umi");
-var import_spl_token = require("@solana/spl-token");
-var import_web34 = require("@solana/web3.js");
-var import_chaindata_provider22 = require("@talismn/chaindata-provider");
+var import_chaindata_provider23 = require("@talismn/chaindata-provider");
 var import_lodash_es13 = require("lodash-es");
-var import_v47 = __toESM(require("zod/v4"));
-var TokenCacheSchema3 = import_v47.default.discriminatedUnion("isValid", [
-  import_v47.default.strictObject({
-    id: import_chaindata_provider22.SolSplTokenSchema.shape.id,
-    isValid: import_v47.default.literal(true),
-    ...import_chaindata_provider22.SolSplTokenSchema.pick({ symbol: true, decimals: true, name: true, logo: true }).shape
-  }),
-  import_v47.default.strictObject({
-    id: import_chaindata_provider22.SolSplTokenSchema.shape.id,
-    isValid: import_v47.default.literal(false)
-  })
-]);
-var METAPLEX_PROGRAM_ID = new import_web34.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
 var fetchTokens5 = async ({
   networkId,
   tokens,
@@ -2306,7 +2400,7 @@ var fetchTokens5 = async ({
 }) => {
   const result = [];
   for (const tokenConfig of tokens) {
-    const tokenId = (0, import_chaindata_provider22.solSplTokenId)(networkId, tokenConfig.mintAddress);
+    const tokenId = (0, import_chaindata_provider23.solSplTokenId)(networkId, tokenConfig.mintAddress);
     let cached = cache[tokenId] && TokenCacheSchema3.safeParse(cache[tokenId]).data;
     if (!cached) {
       const tokenInfo = await fetchOnChainTokenData(connector, tokenId);
@@ -2325,7 +2419,7 @@ var fetchTokens5 = async ({
       cached?.isValid ? (0, import_lodash_es13.omit)(cached, ["isValid"]) : {},
       tokenConfig
     );
-    const parsed = import_chaindata_provider22.SolSplTokenSchema.safeParse(token);
+    const parsed = import_chaindata_provider23.SolSplTokenSchema.safeParse(token);
     if (!parsed.success) {
       log_default.warn("Ignoring token with invalid SolSplTokenSchema", {
         token
@@ -2336,54 +2430,6 @@ var fetchTokens5 = async ({
   }
   return result;
 };
-var ERROR_NO_MINT = "No mint info available";
-var ERROR_NO_METADATA = "No metadata account found";
-var ERROR_INVALID_DATA = "Invalid on-chain data";
-var fetchOnChainTokenData = async (connector, tokenId) => {
-  try {
-    const { networkId, mintAddress } = (0, import_chaindata_provider22.parseSolSplTokenId)(tokenId);
-    const connection = await connector.getConnection(networkId);
-    if (!connection) {
-      log_default.warn(`No connection found for network ${networkId}`);
-      return null;
-    }
-    const mintPubKey = new import_web34.PublicKey(mintAddress);
-    const mintInfo = await connection.getAccountInfo(mintPubKey);
-    if (!mintInfo?.data) throw new Error(ERROR_NO_MINT);
-    const mint = import_spl_token.MintLayout.decode(mintInfo.data);
-    const [metadataPDA] = import_web34.PublicKey.findProgramAddressSync(
-      [Buffer.from("metadata"), METAPLEX_PROGRAM_ID.toBuffer(), mintPubKey.toBuffer()],
-      METAPLEX_PROGRAM_ID
-    );
-    const metadataAccount = await connection.getAccountInfo(new import_web34.PublicKey(metadataPDA));
-    if (!metadataAccount) throw new Error(ERROR_NO_METADATA);
-    const metadata = (0, import_mpl_token_metadata.deserializeMetadata)({
-      publicKey: (0, import_umi.publicKey)(metadataPDA),
-      executable: metadataAccount.executable,
-      owner: (0, import_umi.publicKey)(metadataAccount.owner),
-      lamports: (0, import_umi.sol)(metadataAccount.lamports),
-      data: metadataAccount.data
-    });
-    const parsed = TokenCacheSchema3.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 TokenCacheSchema3.parse({
-        id: tokenId,
-        isValid: false
-      });
-    log_default.warn("Failed to fetch sol-spl token data for %s", tokenId, { err });
-  }
-  return null;
-};
 
 // src/modules/sol-spl/getMiniMetadata.ts
 var getMiniMetadata5 = () => {
@@ -2393,9 +2439,9 @@ var getMiniMetadata5 = () => {
 // src/modules/sol-spl/getTransferCallData.ts
 var import_spl_token2 = require("@solana/spl-token");
 var import_web35 = require("@solana/web3.js");
-var import_chaindata_provider23 = require("@talismn/chaindata-provider");
+var import_chaindata_provider24 = require("@talismn/chaindata-provider");
 var getTransferCallData5 = async ({ from: from2, to, value, token, connector }) => {
-  if (!(0, import_chaindata_provider23.isTokenOfType)(token, MODULE_TYPE5))
+  if (!(0, import_chaindata_provider24.isTokenOfType)(token, MODULE_TYPE5))
     throw new Error(`Token type ${token.type} is not ${MODULE_TYPE5}.`);
   const connection = await connector.getConnection(token.networkId);
   const instructions = [];
@@ -2488,21 +2534,476 @@ var SolSplBalanceModule = {
 };
 
 // src/modules/sol-spl/types.ts
-var import_chaindata_provider24 = require("@talismn/chaindata-provider");
+var import_chaindata_provider25 = require("@talismn/chaindata-provider");
 var import_v48 = __toESM(require("zod/v4"));
 var SolSplTokenConfigSchema = import_v48.default.strictObject({
-  mintAddress: import_chaindata_provider24.SolSplTokenSchema.shape.mintAddress,
+  mintAddress: import_chaindata_provider25.SolSplTokenSchema.shape.mintAddress,
+  ...TokenConfigBaseSchema.shape
+});
+
+// src/modules/sol-token2022/config.ts
+var import_chaindata_provider26 = require("@talismn/chaindata-provider");
+var MODULE_TYPE6 = import_chaindata_provider26.SolToken2022TokenSchema.shape.type.value;
+var PLATFORM6 = import_chaindata_provider26.SolToken2022TokenSchema.shape.platform.value;
+
+// src/modules/sol-token2022/fetchBalances.ts
+var import_web37 = require("@solana/web3.js");
+var import_chaindata_provider28 = require("@talismn/chaindata-provider");
+var import_util3 = require("@talismn/util");
+var import_lodash_es15 = require("lodash-es");
+
+// src/modules/sol-token2022/onChainTokenMetadata.ts
+var import_mpl_token_metadata2 = require("@metaplex-foundation/mpl-token-metadata");
+var import_umi2 = require("@metaplex-foundation/umi");
+var import_spl_token3 = require("@solana/spl-token");
+var import_web36 = require("@solana/web3.js");
+var import_chaindata_provider27 = require("@talismn/chaindata-provider");
+var import_v49 = __toESM(require("zod/v4"));
+var TokenCacheSchema4 = import_v49.default.discriminatedUnion("isValid", [
+  import_v49.default.strictObject({
+    id: import_chaindata_provider27.SolToken2022TokenSchema.shape.id,
+    isValid: import_v49.default.literal(true),
+    ...import_chaindata_provider27.SolToken2022TokenSchema.pick({ symbol: true, decimals: true, name: true, logo: true }).shape
+  }),
+  import_v49.default.strictObject({
+    id: import_chaindata_provider27.SolToken2022TokenSchema.shape.id,
+    isValid: import_v49.default.literal(false)
+  })
+]);
+var METAPLEX_PROGRAM_ID2 = new import_web36.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+var ERROR_NO_MINT2 = "No mint info available";
+var ERROR_NO_METADATA2 = "No metadata account found";
+var ERROR_INVALID_DATA2 = "Invalid on-chain data";
+var fetchOnChainTokenData2 = async (connector, tokenId) => {
+  try {
+    const { networkId, mintAddress } = (0, import_chaindata_provider27.parseSolToken2022TokenId)(tokenId);
+    const connection = await connector.getConnection(networkId);
+    if (!connection) {
+      log_default.warn(`No connection found for network ${networkId}`);
+      return null;
+    }
+    const mintPubKey = new import_web36.PublicKey(mintAddress);
+    const mintInfo = await connection.getAccountInfo(mintPubKey);
+    if (!mintInfo?.data) throw new Error(ERROR_NO_MINT2);
+    const mint = import_spl_token3.MintLayout.decode(mintInfo.data);
+    const token2022Metadata = tryParseToken2022Metadata(mintInfo.data);
+    if (token2022Metadata) {
+      const parsed2 = TokenCacheSchema4.safeParse({
+        id: tokenId,
+        symbol: token2022Metadata.symbol.trim(),
+        name: token2022Metadata.name.trim(),
+        decimals: mint.decimals,
+        isValid: true
+      });
+      if (parsed2.success) return parsed2.data;
+    }
+    const [metadataPDA] = import_web36.PublicKey.findProgramAddressSync(
+      [Buffer.from("metadata"), METAPLEX_PROGRAM_ID2.toBuffer(), mintPubKey.toBuffer()],
+      METAPLEX_PROGRAM_ID2
+    );
+    const metadataAccount = await connection.getAccountInfo(new import_web36.PublicKey(metadataPDA));
+    if (!metadataAccount) throw new Error(ERROR_NO_METADATA2);
+    const metadata = (0, import_mpl_token_metadata2.deserializeMetadata)({
+      publicKey: (0, import_umi2.publicKey)(metadataPDA),
+      executable: metadataAccount.executable,
+      owner: (0, import_umi2.publicKey)(metadataAccount.owner),
+      lamports: (0, import_umi2.sol)(metadataAccount.lamports),
+      data: metadataAccount.data
+    });
+    const parsed = TokenCacheSchema4.safeParse({
+      id: tokenId,
+      symbol: metadata.symbol.trim(),
+      name: metadata.name.trim(),
+      decimals: mint.decimals,
+      isValid: true
+    });
+    if (!parsed.success) throw new Error(ERROR_INVALID_DATA2);
+    return parsed.data;
+  } catch (err) {
+    const msg = err.message;
+    if ([ERROR_NO_MINT2, ERROR_NO_METADATA2, ERROR_INVALID_DATA2].includes(msg))
+      return TokenCacheSchema4.parse({
+        id: tokenId,
+        isValid: false
+      });
+    log_default.warn("Failed to fetch sol-token2022 token data for %s", tokenId, { err });
+  }
+  return null;
+};
+var tryParseToken2022Metadata = (data) => {
+  try {
+    const TLV_START = 166;
+    if (data.length <= TLV_START) return null;
+    let offset = TLV_START;
+    while (offset + 4 <= data.length) {
+      const extType = data.readUInt16LE(offset);
+      const extLen = data.readUInt16LE(offset + 2);
+      const extDataStart = offset + 4;
+      if (extType === 19 && extDataStart + extLen <= data.length) {
+        let pos = extDataStart;
+        pos += 64;
+        const readLenPrefixed = () => {
+          if (pos + 4 > data.length) throw new Error("out of bounds");
+          const len = data.readUInt32LE(pos);
+          pos += 4;
+          if (pos + len > data.length) throw new Error("out of bounds");
+          const str = data.subarray(pos, pos + len).toString("utf8");
+          pos += len;
+          return str;
+        };
+        const name = readLenPrefixed();
+        const symbol = readLenPrefixed();
+        const uri = readLenPrefixed();
+        if (name && symbol) return { name, symbol, uri };
+      }
+      offset = extDataStart + extLen;
+    }
+  } catch {
+  }
+  return null;
+};
+
+// src/modules/sol-token2022/fetchBalances.ts
+var TOKEN_2022_PROGRAM_ID = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
+var dynamicTokenMetadataCache2 = /* @__PURE__ */ new Map();
+var fetchBalances6 = 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 = (0, import_lodash_es15.uniq)(tokensWithAddresses.flatMap(([, addresses]) => addresses));
+  const knownTokenIds = new Set(tokensWithAddresses.map(([token]) => token.id));
+  const unknownMints = /* @__PURE__ */ new Set();
+  const balancesPerAddress = await Promise.all(
+    accountAddresses.map(async (address) => {
+      const tokenAccounts = await connection.getParsedTokenAccountsByOwner(new import_web37.PublicKey(address), {
+        programId: new import_web37.PublicKey(TOKEN_2022_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";
+          const tokenId = (0, import_chaindata_provider28.solToken2022TokenId)(networkId, mintAddress);
+          if (!knownTokenIds.has(tokenId) && value !== "0") unknownMints.add(mintAddress);
+          return {
+            tokenId,
+            networkId,
+            address,
+            source: MODULE_TYPE6,
+            status: "live",
+            value
+          };
+        } catch {
+          log_default.warn("Failed to parse token amount", {
+            address,
+            d
+          });
+          return null;
+        }
+      }).filter(import_util3.isNotNil);
+      setDetectedTokenIds(
+        address,
+        MODULE_TYPE6,
+        balances.map((b) => b.tokenId)
+      );
+      return [address, balances];
+    })
+  );
+  const dynamicTokens = [];
+  if (unknownMints.size) {
+    await Promise.all(
+      Array.from(unknownMints).map(async (mintAddress) => {
+        const tokenId = (0, import_chaindata_provider28.solToken2022TokenId)(networkId, mintAddress);
+        let cached = dynamicTokenMetadataCache2.get(tokenId);
+        if (!cached) {
+          const fetched = await fetchOnChainTokenData2(connector, tokenId);
+          if (fetched) {
+            dynamicTokenMetadataCache2.set(tokenId, fetched);
+            cached = fetched;
+          }
+        }
+        if (!cached || !cached.isValid) return;
+        const token = {
+          id: tokenId,
+          type: MODULE_TYPE6,
+          platform: PLATFORM6,
+          networkId,
+          mintAddress,
+          isDefault: true,
+          symbol: cached.symbol,
+          decimals: cached.decimals,
+          ...cached.name !== void 0 ? { name: cached.name } : {},
+          ...cached.logo !== void 0 ? { logo: cached.logo } : {}
+        };
+        const parsed = import_chaindata_provider28.SolToken2022TokenSchema.safeParse(token);
+        if (!parsed.success) {
+          log_default.warn("Ignoring dynamic sol-token2022 token with invalid schema", { token });
+          return;
+        }
+        dynamicTokens.push(parsed.data);
+      })
+    );
+  }
+  const registeredDynamicIds = new Set(dynamicTokens.map((t) => t.id));
+  const allBalancesByKey = (0, import_lodash_es15.keyBy)(
+    balancesPerAddress.flatMap(([, addressBalances]) => addressBalances),
+    (b) => getBalanceKey2(b.tokenId, b.address)
+  );
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
+  const success = balanceDefs.map((bd) => {
+    const found = allBalancesByKey[getBalanceKey2(bd.token.id, bd.address)];
+    return found ?? {
+      tokenId: bd.token.id,
+      networkId: bd.token.networkId,
+      address: bd.address,
+      source: MODULE_TYPE6,
+      status: "live",
+      value: "0"
+    };
+  });
+  for (const balance of balancesPerAddress.flatMap(([, addressBalances]) => addressBalances)) {
+    if (registeredDynamicIds.has(balance.tokenId)) success.push(balance);
+  }
+  return { success, errors: [], dynamicTokens };
+};
+var getBalanceKey2 = (tokenId, address) => `${tokenId}:${address}`;
+
+// src/modules/sol-token2022/fetchTokens.ts
+var import_chaindata_provider29 = require("@talismn/chaindata-provider");
+var import_lodash_es16 = require("lodash-es");
+var fetchTokens6 = async ({
+  networkId,
+  tokens,
+  connector,
+  cache
+}) => {
+  const result = [];
+  for (const tokenConfig of tokens) {
+    const tokenId = (0, import_chaindata_provider29.solToken2022TokenId)(networkId, tokenConfig.mintAddress);
+    let cached = cache[tokenId] && TokenCacheSchema4.safeParse(cache[tokenId]).data;
+    if (!cached) {
+      const tokenInfo = await fetchOnChainTokenData2(connector, tokenId);
+      if (tokenInfo) cache[tokenId] = tokenInfo;
+    }
+    cached = cache[tokenId] && TokenCacheSchema4.safeParse(cache[tokenId]).data;
+    if (cached?.isValid === false) continue;
+    const base = {
+      id: tokenId,
+      type: MODULE_TYPE6,
+      platform: PLATFORM6,
+      networkId
+    };
+    const token = (0, import_lodash_es16.assign)(
+      base,
+      cached?.isValid ? (0, import_lodash_es16.omit)(cached, ["isValid"]) : {},
+      tokenConfig
+    );
+    const parsed = import_chaindata_provider29.SolToken2022TokenSchema.safeParse(token);
+    if (!parsed.success) {
+      log_default.warn("Ignoring token with invalid SolToken2022TokenSchema", {
+        token
+      });
+      continue;
+    }
+    result.push(parsed.data);
+  }
+  return result;
+};
+
+// src/modules/sol-token2022/getMiniMetadata.ts
+var getMiniMetadata6 = () => {
+  throw new Error("MiniMetadata is not supported for solana tokens");
+};
+
+// src/modules/sol-token2022/getTransferCallData.ts
+var import_spl_token4 = require("@solana/spl-token");
+var import_web38 = require("@solana/web3.js");
+var import_chaindata_provider30 = require("@talismn/chaindata-provider");
+var getTransferCallData6 = async ({ from: from2, to, value, token, connector }) => {
+  if (!(0, import_chaindata_provider30.isTokenOfType)(token, MODULE_TYPE6))
+    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE6}.`);
+  const connection = await connector.getConnection(token.networkId);
+  const mintPubkey = new import_web38.PublicKey(token.mintAddress);
+  const fromWallet = new import_web38.PublicKey(from2);
+  const toWallet = new import_web38.PublicKey(to);
+  const mintAccount = await (0, import_spl_token4.getMint)(connection, mintPubkey, void 0, import_spl_token4.TOKEN_2022_PROGRAM_ID);
+  const nonTransferable = (0, import_spl_token4.getNonTransferable)(mintAccount);
+  if (nonTransferable) throw new Error("This token is non-transferable.");
+  const transferFeeConfig = (0, import_spl_token4.getTransferFeeConfig)(mintAccount);
+  const transferHook = (0, import_spl_token4.getTransferHook)(mintAccount);
+  const instructions = [];
+  const fromTokenAccount = await (0, import_spl_token4.getAssociatedTokenAddress)(
+    mintPubkey,
+    fromWallet,
+    false,
+    import_spl_token4.TOKEN_2022_PROGRAM_ID
+  );
+  const toTokenAccount = await (0, import_spl_token4.getAssociatedTokenAddress)(
+    mintPubkey,
+    toWallet,
+    false,
+    import_spl_token4.TOKEN_2022_PROGRAM_ID
+  );
+  if (!await tokenAccountExists2(connection, toTokenAccount)) {
+    instructions.push(
+      (0, import_spl_token4.createAssociatedTokenAccountInstruction)(
+        fromWallet,
+        toTokenAccount,
+        toWallet,
+        mintPubkey,
+        import_spl_token4.TOKEN_2022_PROGRAM_ID
+      )
+    );
+  }
+  const amount = BigInt(value);
+  const transferFee = transferFeeConfig ? await calculateCurrentEpochTransferFee(connection, transferFeeConfig, amount) : 0n;
+  if (transferFeeConfig && transferHook) {
+    instructions.push(
+      await (0, import_spl_token4.createTransferCheckedWithFeeAndTransferHookInstruction)(
+        connection,
+        fromTokenAccount,
+        mintPubkey,
+        toTokenAccount,
+        fromWallet,
+        amount,
+        token.decimals,
+        transferFee,
+        [],
+        void 0,
+        import_spl_token4.TOKEN_2022_PROGRAM_ID
+      )
+    );
+  } else if (transferFeeConfig) {
+    instructions.push(
+      (0, import_spl_token4.createTransferCheckedWithFeeInstruction)(
+        fromTokenAccount,
+        mintPubkey,
+        toTokenAccount,
+        fromWallet,
+        amount,
+        token.decimals,
+        transferFee,
+        [],
+        import_spl_token4.TOKEN_2022_PROGRAM_ID
+      )
+    );
+  } else if (transferHook) {
+    instructions.push(
+      await (0, import_spl_token4.createTransferCheckedWithTransferHookInstruction)(
+        connection,
+        fromTokenAccount,
+        mintPubkey,
+        toTokenAccount,
+        fromWallet,
+        amount,
+        token.decimals,
+        [],
+        void 0,
+        import_spl_token4.TOKEN_2022_PROGRAM_ID
+      )
+    );
+  } else {
+    instructions.push(
+      (0, import_spl_token4.createTransferCheckedInstruction)(
+        fromTokenAccount,
+        mintPubkey,
+        toTokenAccount,
+        fromWallet,
+        amount,
+        token.decimals,
+        [],
+        import_spl_token4.TOKEN_2022_PROGRAM_ID
+      )
+    );
+  }
+  return instructions;
+};
+var tokenAccountExists2 = async (connection, address) => {
+  try {
+    await (0, import_spl_token4.getAccount)(connection, address, void 0, import_spl_token4.TOKEN_2022_PROGRAM_ID);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var calculateToken2022TransferFee = (transferFeeConfig, epoch, amount) => {
+  return (0, import_spl_token4.calculateEpochFee)(transferFeeConfig, epoch, amount);
+};
+var calculateCurrentEpochTransferFee = async (connection, transferFeeConfig, amount) => {
+  const { epoch } = await connection.getEpochInfo();
+  return calculateToken2022TransferFee(transferFeeConfig, BigInt(epoch), amount);
+};
+
+// src/modules/sol-token2022/subscribeBalances.ts
+var import_lodash_es17 = require("lodash-es");
+var import_rxjs8 = require("rxjs");
+var SUBSCRIPTION_INTERVAL6 = 6e3;
+var subscribeBalances6 = ({
+  networkId,
+  tokensWithAddresses,
+  connector
+}) => {
+  if (!tokensWithAddresses.length) return (0, import_rxjs8.of)({ success: [], errors: [] });
+  return new import_rxjs8.Observable((subscriber) => {
+    const abortController = new AbortController();
+    const poll = async () => {
+      try {
+        if (abortController.signal.aborted) return;
+        const balances = await fetchBalances6({
+          networkId,
+          tokensWithAddresses,
+          connector
+        });
+        if (abortController.signal.aborted) return;
+        subscriber.next(balances);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL6);
+      } catch (error) {
+        log_default.error("Error", {
+          module: MODULE_TYPE6,
+          networkId,
+          addressesByToken: tokensWithAddresses,
+          error
+        });
+        subscriber.error(error);
+      }
+    };
+    poll();
+    return () => {
+      abortController.abort();
+    };
+  }).pipe((0, import_rxjs8.distinctUntilChanged)(import_lodash_es17.isEqual));
+};
+
+// src/modules/sol-token2022/module.ts
+var SolToken2022BalanceModule = {
+  type: MODULE_TYPE6,
+  platform: PLATFORM6,
+  getMiniMetadata: getMiniMetadata6,
+  fetchTokens: fetchTokens6,
+  fetchBalances: fetchBalances6,
+  subscribeBalances: subscribeBalances6,
+  getTransferCallData: getTransferCallData6
+};
+
+// src/modules/sol-token2022/types.ts
+var import_chaindata_provider31 = require("@talismn/chaindata-provider");
+var import_v410 = __toESM(require("zod/v4"));
+var SolToken2022TokenConfigSchema = import_v410.default.strictObject({
+  mintAddress: import_chaindata_provider31.SolToken2022TokenSchema.shape.mintAddress,
   ...TokenConfigBaseSchema.shape
 });
 
 // src/modules/substrate-assets/config.ts
-var import_chaindata_provider25 = require("@talismn/chaindata-provider");
-var MODULE_TYPE6 = import_chaindata_provider25.SubAssetsTokenSchema.shape.type.value;
-var PLATFORM6 = import_chaindata_provider25.SubAssetsTokenSchema.shape.platform.value;
+var import_chaindata_provider32 = require("@talismn/chaindata-provider");
+var MODULE_TYPE7 = import_chaindata_provider32.SubAssetsTokenSchema.shape.type.value;
+var PLATFORM7 = import_chaindata_provider32.SubAssetsTokenSchema.shape.platform.value;
 
 // src/modules/substrate-assets/buildQueries.ts
 var import_scale4 = require("@talismn/scale");
-var import_util3 = require("@talismn/util");
+var import_util4 = require("@talismn/util");
 var buildQueries = (networkId, balanceDefs, miniMetadata) => {
   const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
     storage: ["Assets", "Account"]
@@ -2551,7 +3052,7 @@ var buildQueries = (networkId, balanceDefs, miniMetadata) => {
       stateKeys: [stateKey],
       decodeResult
     };
-  }).filter(import_util3.isNotNil);
+  }).filter(import_util4.isNotNil);
 };
 var tryEncode = (scaleCoder, ...args) => {
   try {
@@ -2562,7 +3063,7 @@ var tryEncode = (scaleCoder, ...args) => {
 };
 
 // src/modules/substrate-assets/fetchBalances.ts
-var fetchBalances6 = async ({
+var fetchBalances7 = async ({
   networkId,
   tokensWithAddresses,
   connector,
@@ -2571,7 +3072,7 @@ var fetchBalances6 = async ({
   if (!tokensWithAddresses.length) return { success: [], errors: [] };
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!miniMetadata?.data) {
-    log_default.warn(`MiniMetadata is required for fetching ${MODULE_TYPE6} balances on ${networkId}.`);
+    log_default.warn(`MiniMetadata is required for fetching ${MODULE_TYPE7} balances on ${networkId}.`);
     return {
       success: [],
       errors: balanceDefs.map((def) => ({
@@ -2581,20 +3082,20 @@ var fetchBalances6 = async ({
       }))
     };
   }
-  if (miniMetadata.source !== MODULE_TYPE6) {
-    log_default.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE6}.`);
+  if (miniMetadata.source !== MODULE_TYPE7) {
+    log_default.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE7}.`);
     return {
       success: [],
       errors: balanceDefs.map((def) => ({
         tokenId: def.token.id,
         address: def.address,
-        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE6}`)
+        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE7}`)
       }))
     };
   }
   if (miniMetadata.chainId !== networkId) {
     log_default.warn(
-      `Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE6}. Expected chainId is ${networkId}`
+      `Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE7}. Expected chainId is ${networkId}`
     );
     return {
       success: [],
@@ -2618,7 +3119,7 @@ var fetchBalances6 = async ({
           address: def.address,
           networkId,
           tokenId: def.token.id,
-          source: MODULE_TYPE6,
+          source: MODULE_TYPE7,
           status: "live",
           values: [
             { type: "free", label: "free", amount: "0" },
@@ -2632,10 +3133,10 @@ var fetchBalances6 = async ({
 };
 
 // src/modules/substrate-assets/fetchTokens.ts
-var import_chaindata_provider26 = require("@talismn/chaindata-provider");
+var import_chaindata_provider33 = require("@talismn/chaindata-provider");
 var import_scale5 = require("@talismn/scale");
-var import_lodash_es15 = require("lodash-es");
-var fetchTokens6 = async ({
+var import_lodash_es18 = require("lodash-es");
+var fetchTokens7 = async ({
   networkId,
   tokens,
   connector,
@@ -2660,7 +3161,7 @@ var fetchTokens6 = async ({
   ]);
   const assetStorageEntries = assetStorageResults.length ? assetStorageResults[0].changes : [];
   const metadataStorageEntries = metadataStorageResults.length ? metadataStorageResults[0].changes : [];
-  const assetByAssetId = (0, import_lodash_es15.keyBy)(
+  const assetByAssetId = (0, import_lodash_es18.keyBy)(
     assetStorageEntries.map(([key, value]) => {
       const [assetId] = assetCodec.keys.dec(key);
       const asset = assetCodec.value.dec(value);
@@ -2668,7 +3169,7 @@ var fetchTokens6 = async ({
     }),
     (a) => a.assetId
   );
-  const metadataByAssetId = (0, import_lodash_es15.keyBy)(
+  const metadataByAssetId = (0, import_lodash_es18.keyBy)(
     metadataStorageEntries.map(([key, value]) => {
       const [assetId] = metadataCodec.keys.dec(key);
       const metadata = metadataCodec.value.dec(value);
@@ -2682,14 +3183,14 @@ var fetchTokens6 = async ({
     }),
     (a) => a.assetId
   );
-  const allTokens = (0, import_lodash_es15.keys)(assetByAssetId).map(
-    (assetId) => (0, import_lodash_es15.assign)({}, assetByAssetId[assetId], metadataByAssetId[assetId] ?? void 0)
+  const allTokens = (0, import_lodash_es18.keys)(assetByAssetId).map(
+    (assetId) => (0, import_lodash_es18.assign)({}, assetByAssetId[assetId], metadataByAssetId[assetId] ?? void 0)
   );
-  const configTokenByAssetId = (0, import_lodash_es15.keyBy)(tokens, (t) => t.assetId);
+  const configTokenByAssetId = (0, import_lodash_es18.keyBy)(tokens, (t) => t.assetId);
   return allTokens.map(
     (asset) => ({
-      id: (0, import_chaindata_provider26.subAssetTokenId)(networkId, String(asset.assetId)),
-      type: MODULE_TYPE6,
+      id: (0, import_chaindata_provider33.subAssetTokenId)(networkId, String(asset.assetId)),
+      type: MODULE_TYPE7,
       platform: "polkadot",
       networkId,
       assetId: String(asset.assetId),
@@ -2706,21 +3207,21 @@ var fetchTokens6 = async ({
     return configToken || token.isSufficient;
   }).map((token) => {
     const configToken = configTokenByAssetId[token.assetId];
-    return configToken ? (0, import_lodash_es15.assign)({}, token, configToken) : token;
+    return configToken ? (0, import_lodash_es18.assign)({}, token, configToken) : token;
   }).filter((t) => {
-    const parsed = import_chaindata_provider26.SubAssetsTokenSchema.safeParse(t);
+    const parsed = import_chaindata_provider33.SubAssetsTokenSchema.safeParse(t);
     return parsed.success;
   });
 };
 
 // src/modules/substrate-assets/getMiniMetadata.ts
-var import_chaindata_provider37 = require("@talismn/chaindata-provider");
+var import_chaindata_provider44 = require("@talismn/chaindata-provider");
 var import_scale11 = require("@talismn/scale");
 
 // src/types/balances.ts
-var import_chaindata_provider35 = require("@talismn/chaindata-provider");
+var import_chaindata_provider42 = require("@talismn/chaindata-provider");
 var import_token_rates2 = require("@talismn/token-rates");
-var import_util6 = require("@talismn/util");
+var import_util7 = require("@talismn/util");
 var import_bignumber2 = __toESM(require("bignumber.js"));
 
 // src/modules/substrate-dtao/alphaPrice.ts
@@ -2740,12 +3241,12 @@ var taoToAlpha = (tao, scaledAlphaPrice) => {
 };
 
 // src/modules/substrate-dtao/getDtaoTokenRates.ts
-var import_chaindata_provider27 = require("@talismn/chaindata-provider");
+var import_chaindata_provider34 = require("@talismn/chaindata-provider");
 var import_token_rates = require("@talismn/token-rates");
 var ONE_ALPHA = 10n ** TAO_DECIMALS;
 var getDTaoTokenRates = (token, tokenRates, scaledAlphaPrice) => {
   try {
-    const taoTokenId = (0, import_chaindata_provider27.subNativeTokenId)(token.networkId);
+    const taoTokenId = (0, import_chaindata_provider34.subNativeTokenId)(token.networkId);
     const taoTokenRates = tokenRates[taoTokenId];
     if (!taoTokenRates) return null;
     if (token.netuid === 0) return structuredClone(taoTokenRates);
@@ -2772,18 +3273,18 @@ var getDTaoTokenRates = (token, tokenRates, scaledAlphaPrice) => {
 };
 
 // src/modules/substrate-dtao/config.ts
-var import_chaindata_provider28 = require("@talismn/chaindata-provider");
-var MODULE_TYPE7 = import_chaindata_provider28.SubDTaoTokenSchema.shape.type.value;
-var PLATFORM7 = import_chaindata_provider28.SubDTaoTokenSchema.shape.platform.value;
+var import_chaindata_provider35 = require("@talismn/chaindata-provider");
+var MODULE_TYPE8 = import_chaindata_provider35.SubDTaoTokenSchema.shape.type.value;
+var PLATFORM8 = import_chaindata_provider35.SubDTaoTokenSchema.shape.platform.value;
 
 // src/modules/substrate-dtao/fetchBalances.ts
-var import_chaindata_provider30 = require("@talismn/chaindata-provider");
+var import_chaindata_provider37 = require("@talismn/chaindata-provider");
 var import_scale6 = require("@talismn/scale");
-var import_util4 = require("@talismn/util");
-var import_lodash_es16 = require("lodash-es");
+var import_util5 = require("@talismn/util");
+var import_lodash_es19 = require("lodash-es");
 
 // src/modules/substrate-dtao/calculatePendingRootClaimable.ts
-var import_chaindata_provider29 = require("@talismn/chaindata-provider");
+var import_chaindata_provider36 = require("@talismn/chaindata-provider");
 var calculatePendingRootClaimable = ({
   stake,
   hotkey,
@@ -2805,8 +3306,8 @@ var calculatePendingRootClaimable = ({
     const pendingRootClaim = totalClaimable > alreadyClaimed ? totalClaimable - alreadyClaimed : 0n;
     pendingRootClaimBalances.push({
       address,
-      tokenId: (0, import_chaindata_provider29.subDTaoTokenId)(networkId, netuid, hotkey),
-      baseTokenId: (0, import_chaindata_provider29.subDTaoTokenId)(networkId, netuid),
+      tokenId: (0, import_chaindata_provider36.subDTaoTokenId)(networkId, netuid, hotkey),
+      baseTokenId: (0, import_chaindata_provider36.subDTaoTokenId)(networkId, netuid),
       hotkey,
       netuid,
       scaledAlphaPrice,
@@ -2819,7 +3320,7 @@ var calculatePendingRootClaimable = ({
 
 // src/modules/substrate-dtao/fetchBalances.ts
 var ROOT_NETUID = 0;
-var fetchBalances7 = async ({
+var fetchBalances8 = async ({
   networkId,
   tokensWithAddresses,
   connector,
@@ -2828,7 +3329,7 @@ var fetchBalances7 = async ({
   if (!tokensWithAddresses.length) return { success: [], errors: [] };
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!miniMetadata?.data) {
-    log_default.warn(`MiniMetadata is required for fetching ${MODULE_TYPE7} balances on ${networkId}.`, {
+    log_default.warn(`MiniMetadata is required for fetching ${MODULE_TYPE8} balances on ${networkId}.`, {
       tokensWithAddresses
     });
     return {
@@ -2840,20 +3341,20 @@ var fetchBalances7 = async ({
       }))
     };
   }
-  if (miniMetadata.source !== MODULE_TYPE7) {
-    log_default.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE7}.`);
+  if (miniMetadata.source !== MODULE_TYPE8) {
+    log_default.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE8}.`);
     return {
       success: [],
       errors: balanceDefs.map((def) => ({
         tokenId: def.token.id,
         address: def.address,
-        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE7}`)
+        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE8}`)
       }))
     };
   }
   if (miniMetadata.chainId !== networkId) {
     log_default.warn(
-      `Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE7}. Expected chainId is ${networkId}`
+      `Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE8}. Expected chainId is ${networkId}`
     );
     return {
       success: [],
@@ -2864,7 +3365,7 @@ var fetchBalances7 = async ({
       }))
     };
   }
-  const addresses = (0, import_lodash_es16.uniq)(balanceDefs.map((def) => def.address));
+  const addresses = (0, import_lodash_es19.uniq)(balanceDefs.map((def) => def.address));
   try {
     const [stakeInfos, dynamicInfos] = await Promise.all([
       fetchRuntimeCallResult(
@@ -2884,7 +3385,7 @@ var fetchBalances7 = async ({
         []
       )
     ]);
-    const rootHotkeys = (0, import_lodash_es16.uniq)(
+    const rootHotkeys = (0, import_lodash_es19.uniq)(
       stakeInfos.flatMap(
         ([, stakes]) => stakes.filter((stake) => stake.netuid === ROOT_NETUID).map((stake) => stake.hotkey)
       )
@@ -2909,7 +3410,7 @@ var fetchBalances7 = async ({
       miniMetadata.data,
       addressHotkeyNetuidPairs
     ) : /* @__PURE__ */ new Map();
-    const dynamicInfoByNetuid = (0, import_lodash_es16.keyBy)(dynamicInfos.filter(import_util4.isNotNil), (info) => info.netuid);
+    const dynamicInfoByNetuid = (0, import_lodash_es19.keyBy)(dynamicInfos.filter(import_util5.isNotNil), (info) => info.netuid);
     const upsertBalance = (acc, address, tokenId, balance) => {
       const key = `${address}:${tokenId}`;
       const recordedBalance = acc[key];
@@ -2933,8 +3434,8 @@ var fetchBalances7 = async ({
           const scaledAlphaPrice = dynamicInfo ? getScaledAlphaPrice(dynamicInfo.alpha_in, dynamicInfo.tao_in) : 0n;
           const balance = {
             address,
-            tokenId: (0, import_chaindata_provider30.subDTaoTokenId)(networkId, stake.netuid, stake.hotkey),
-            baseTokenId: (0, import_chaindata_provider30.subDTaoTokenId)(networkId, stake.netuid),
+            tokenId: (0, import_chaindata_provider37.subDTaoTokenId)(networkId, stake.netuid, stake.hotkey),
+            baseTokenId: (0, import_chaindata_provider37.subDTaoTokenId)(networkId, stake.netuid),
             stake: stake.stake,
             hotkey: stake.hotkey,
             netuid: stake.netuid,
@@ -2963,7 +3464,7 @@ var fetchBalances7 = async ({
       {}
     );
     const balances = Object.values(balancesRaw);
-    const tokensById = (0, import_lodash_es16.keyBy)(
+    const tokensById = (0, import_lodash_es19.keyBy)(
       tokensWithAddresses.map(([token]) => token),
       (t) => t.id
     );
@@ -2972,8 +3473,8 @@ var fetchBalances7 = async ({
       if (!balanceDefs.some((def) => def.token.id === bal.tokenId)) {
         const baseToken = tokensById[bal.baseTokenId];
         if (baseToken) {
-          const cleanToken = (0, import_chaindata_provider30.getCleanToken)(baseToken);
-          const newToken = import_chaindata_provider30.TokenSchema.parse({
+          const cleanToken = (0, import_chaindata_provider37.getCleanToken)(baseToken);
+          const newToken = import_chaindata_provider37.TokenSchema.parse({
             ...cleanToken,
             id: bal.tokenId,
             hotkey: bal.hotkey
@@ -3017,7 +3518,7 @@ var fetchBalances7 = async ({
         address: def.address,
         networkId,
         tokenId: def.token.id,
-        source: MODULE_TYPE7,
+        source: MODULE_TYPE8,
         status: "live",
         values: values3
       };
@@ -3184,15 +3685,15 @@ var fetchRootClaimedAmounts = async (connector, networkId, metadataRpc, addressH
 };
 
 // src/modules/substrate-dtao/fetchTokens.ts
-var import_chaindata_provider31 = require("@talismn/chaindata-provider");
+var import_chaindata_provider38 = require("@talismn/chaindata-provider");
 var import_scale7 = require("@talismn/scale");
-var import_util5 = require("@talismn/util");
-var import_lodash_es17 = require("lodash-es");
+var import_util6 = require("@talismn/util");
+var import_lodash_es20 = require("lodash-es");
 var NATIVE_TOKEN_SYMBOLS = {
   "bittensor": "TAO",
   "bittensor-testnet": "testTAO"
 };
-var fetchTokens7 = async ({
+var fetchTokens8 = async ({
   networkId,
   connector,
   tokens,
@@ -3211,7 +3712,7 @@ var fetchTokens7 = async ({
       []
     )
   ]);
-  return dynamicInfos.filter(import_util5.isNotNil).map((info) => {
+  return dynamicInfos.filter(import_util6.isNotNil).map((info) => {
     const config = tokens.find((t) => t.netuid === info.netuid);
     let symbol = new TextDecoder().decode(Uint8Array.from(info.token_symbol));
     const subnetName = info.subnet_identity?.subnet_name?.asText() ?? (info.netuid === 0 ? "Root" : `Subnet ${info.netuid}`);
@@ -3220,9 +3721,9 @@ var fetchTokens7 = async ({
       symbol = NATIVE_TOKEN_SYMBOLS[networkId];
     const isTransferable = transferableTokensMap[info.netuid] ?? true;
     const token = {
-      id: (0, import_chaindata_provider31.subDTaoTokenId)(networkId, info.netuid),
-      type: MODULE_TYPE7,
-      platform: PLATFORM7,
+      id: (0, import_chaindata_provider38.subDTaoTokenId)(networkId, info.netuid),
+      type: MODULE_TYPE8,
+      platform: PLATFORM8,
       networkId,
       netuid: info.netuid,
       isDefault: true,
@@ -3234,7 +3735,7 @@ var fetchTokens7 = async ({
     };
     return Object.assign({}, token, config);
   }).filter((t) => {
-    const parsed = import_chaindata_provider31.SubDTaoTokenSchema.safeParse(t);
+    const parsed = import_chaindata_provider38.SubDTaoTokenSchema.safeParse(t);
     return parsed.success;
   });
 };
@@ -3250,7 +3751,7 @@ var fetchTransferableTokensMap = async (connector, metadata, networkId) => {
     [transferToggleKeys]
   );
   const transferToggleEntries = transferToggleResults.length ? transferToggleResults[0].changes : [];
-  return (0, import_lodash_es17.fromPairs)(
+  return (0, import_lodash_es20.fromPairs)(
     transferToggleEntries.map(([key, value]) => {
       const [netuid] = transferToggleCodec.keys.dec(key);
       const isTransferable = transferToggleCodec.value.dec(value);
@@ -3260,14 +3761,14 @@ var fetchTransferableTokensMap = async (connector, metadata, networkId) => {
 };
 
 // src/modules/substrate-dtao/getMiniMetadata.ts
-var import_chaindata_provider32 = require("@talismn/chaindata-provider");
+var import_chaindata_provider39 = require("@talismn/chaindata-provider");
 var import_scale8 = require("@talismn/scale");
-var getMiniMetadata6 = ({
+var getMiniMetadata7 = ({
   networkId,
   specVersion,
   metadataRpc
 }) => {
-  const source = MODULE_TYPE7;
+  const source = MODULE_TYPE8;
   const chainId = networkId;
   const systemVersion = getConstantValue(metadataRpc, "System", "Version");
   if (specVersion !== systemVersion.spec_version)
@@ -3285,7 +3786,7 @@ var getMiniMetadata6 = ({
     source,
     chainId,
     specVersion,
-    version: import_chaindata_provider32.MINIMETADATA_VERSION,
+    version: import_chaindata_provider39.MINIMETADATA_VERSION,
     data: getData(metadataRpc),
     extra: null
   };
@@ -3313,19 +3814,19 @@ var getData = (metadataRpc) => {
 
 // src/modules/substrate-dtao/getTransferCallData.ts
 var import_utils3 = require("@polkadot-api/utils");
-var import_chaindata_provider33 = require("@talismn/chaindata-provider");
+var import_chaindata_provider40 = require("@talismn/chaindata-provider");
 var import_scale9 = require("@talismn/scale");
 var import_polkadot_api = require("polkadot-api");
-var getTransferCallData6 = ({
+var getTransferCallData7 = ({
   from: from2,
   to,
   value,
   token,
   metadataRpc
 }) => {
-  if (!(0, import_chaindata_provider33.isTokenOfType)(token, MODULE_TYPE7))
-    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE7}.`);
-  const { netuid: subnetId, hotkey } = (0, import_chaindata_provider33.parseSubDTaoTokenId)(token.id);
+  if (!(0, import_chaindata_provider40.isTokenOfType)(token, MODULE_TYPE8))
+    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE8}.`);
+  const { netuid: subnetId, hotkey } = (0, import_chaindata_provider40.parseSubDTaoTokenId)(token.id);
   if (!hotkey) throw new Error(`Missing hotkey`);
   const { builder } = (0, import_scale9.parseMetadataRpc)(metadataRpc);
   const { codec, location } = builder.buildCall("SubtensorModule", "transfer_stake");
@@ -3344,22 +3845,22 @@ var getTransferCallData6 = ({
 };
 
 // src/modules/substrate-dtao/subscribeBalances.ts
-var import_lodash_es18 = require("lodash-es");
-var import_rxjs8 = require("rxjs");
-var SUBSCRIPTION_INTERVAL6 = 6e3;
-var subscribeBalances6 = ({
+var import_lodash_es21 = require("lodash-es");
+var import_rxjs9 = require("rxjs");
+var SUBSCRIPTION_INTERVAL7 = 6e3;
+var subscribeBalances7 = ({
   networkId,
   tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
-  if (!tokensWithAddresses.length) return (0, import_rxjs8.of)({ success: [], errors: [] });
-  return new import_rxjs8.Observable((subscriber) => {
+  if (!tokensWithAddresses.length) return (0, import_rxjs9.of)({ success: [], errors: [] });
+  return new import_rxjs9.Observable((subscriber) => {
     const abortController = new AbortController();
     const poll = async () => {
       try {
         if (abortController.signal.aborted) return;
-        const balances = await fetchBalances7({
+        const balances = await fetchBalances8({
           networkId,
           tokensWithAddresses,
           connector,
@@ -3367,10 +3868,10 @@ var subscribeBalances6 = ({
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL6);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL7);
       } catch (error) {
         log_default.error("Error", {
-          module: MODULE_TYPE7,
+          module: MODULE_TYPE8,
           networkId,
           miniMetadata,
           addressesByToken: tokensWithAddresses,
@@ -3383,25 +3884,25 @@ var subscribeBalances6 = ({
     return () => {
       abortController.abort();
     };
-  }).pipe((0, import_rxjs8.distinctUntilChanged)(import_lodash_es18.isEqual));
+  }).pipe((0, import_rxjs9.distinctUntilChanged)(import_lodash_es21.isEqual));
 };
 
 // src/modules/substrate-dtao/module.ts
 var SubDTaoBalanceModule = {
-  type: MODULE_TYPE7,
-  platform: PLATFORM7,
-  getMiniMetadata: getMiniMetadata6,
-  fetchTokens: fetchTokens7,
-  fetchBalances: fetchBalances7,
-  subscribeBalances: subscribeBalances6,
-  getTransferCallData: getTransferCallData6
+  type: MODULE_TYPE8,
+  platform: PLATFORM8,
+  getMiniMetadata: getMiniMetadata7,
+  fetchTokens: fetchTokens8,
+  fetchBalances: fetchBalances8,
+  subscribeBalances: subscribeBalances7,
+  getTransferCallData: getTransferCallData7
 };
 
 // src/modules/substrate-dtao/types.ts
-var import_chaindata_provider34 = require("@talismn/chaindata-provider");
-var import_v49 = __toESM(require("zod/v4"));
-var SubDTaoTokenConfigSchema = import_v49.default.strictObject({
-  netuid: import_chaindata_provider34.SubDTaoTokenSchema.shape.netuid,
+var import_chaindata_provider41 = require("@talismn/chaindata-provider");
+var import_v411 = __toESM(require("zod/v4"));
+var SubDTaoTokenConfigSchema = import_v411.default.strictObject({
+  netuid: import_chaindata_provider41.SubDTaoTokenSchema.shape.netuid,
   ...TokenConfigBaseSchema.shape
 });
 
@@ -3409,7 +3910,7 @@ var SubDTaoTokenConfigSchema = import_v49.default.strictObject({
 function excludeFromTransferableAmount(locks) {
   if (typeof locks === "string") return BigInt(locks);
   if (!Array.isArray(locks)) locks = [locks];
-  return locks.filter((lock) => lock.includeInTransferable !== true).map((lock) => lock.amount.planck).reduce((max, lock) => import_util6.BigMath.max(max, lock), 0n);
+  return locks.filter((lock) => lock.includeInTransferable !== true).map((lock) => lock.amount.planck).reduce((max, lock) => import_util7.BigMath.max(max, lock), 0n);
 }
 function excludeFromFeePayableLocks(locks) {
   if (typeof locks === "string") return [];
@@ -3437,7 +3938,7 @@ var Balances = class _Balances {
     if (balances instanceof Balance) return new _Balances([balances], hydrate);
     if (!Array.isArray(balances)) return new _Balances(Object.values(balances), hydrate);
     if (balances.length === 0) return this;
-    if (!(0, import_util6.isArrayOf)(balances, Balance))
+    if (!(0, import_util7.isArrayOf)(balances, Balance))
       return new _Balances(
         balances.map((storage) => new Balance(storage)),
         hydrate
@@ -3631,7 +4132,7 @@ var Balance = class {
     if (hydrate !== void 0) this.#db = hydrate;
   };
   #format = (balance) => new BalanceFormatter(
-    (0, import_util6.isBigInt)(balance) ? balance.toString() : balance,
+    (0, import_util7.isBigInt)(balance) ? balance.toString() : balance,
     this.decimals || void 0,
     this.rates
   );
@@ -3667,8 +4168,8 @@ var Balance = class {
   }
   get rates() {
     if (this.isSource("evm-uniswapv2") && this.token?.type === "evm-uniswapv2") {
-      const tokenId0 = (0, import_chaindata_provider35.evmErc20TokenId)(this.networkId, this.token.tokenAddress0);
-      const tokenId1 = (0, import_chaindata_provider35.evmErc20TokenId)(this.networkId, this.token.tokenAddress1);
+      const tokenId0 = (0, import_chaindata_provider42.evmErc20TokenId)(this.networkId, this.token.tokenAddress0);
+      const tokenId1 = (0, import_chaindata_provider42.evmErc20TokenId)(this.networkId, this.token.tokenAddress1);
       const decimals = this.token.decimals;
       const decimals0 = this.token.decimals0;
       const decimals1 = this.token.decimals1;
@@ -3776,7 +4277,7 @@ var Balance = class {
   /** The frozen balance of this token. Is included in the free amount. */
   get locked() {
     return this.#format(
-      this.locks.map(({ amount }) => amount.planck).reduce((a, b) => import_util6.BigMath.max(a, b), 0n)
+      this.locks.map(({ amount }) => amount.planck).reduce((a, b) => import_util7.BigMath.max(a, b), 0n)
     );
   }
   get locks() {
@@ -3800,15 +4301,15 @@ var Balance = class {
     const oldTransferableCalculation = () => {
       if (this.locks.length === 0) return this.free;
       const excludeAmount = excludeFromTransferableAmount(this.locks);
-      return this.#format(import_util6.BigMath.max(this.free.planck - excludeAmount, 0n));
+      return this.#format(import_util7.BigMath.max(this.free.planck - excludeAmount, 0n));
     };
     const newTransferableCalculation = () => {
       if (this.locks.length === 0) return this.free;
-      const untouchableAmount = import_util6.BigMath.max(
+      const untouchableAmount = import_util7.BigMath.max(
         excludeFromTransferableAmount(this.locks) - this.reserved.planck,
         0n
       );
-      return this.#format(import_util6.BigMath.max(this.free.planck - untouchableAmount, 0n));
+      return this.#format(import_util7.BigMath.max(this.free.planck - untouchableAmount, 0n));
     };
     if (this.#storage.useLegacyTransferableCalculation) return oldTransferableCalculation();
     return newTransferableCalculation();
@@ -3820,7 +4321,7 @@ var Balance = class {
    */
   get unavailable() {
     const oldCalculation = () => this.locked.planck + this.reserved.planck;
-    const newCalculation = () => import_util6.BigMath.max(this.locked.planck, this.reserved.planck);
+    const newCalculation = () => import_util7.BigMath.max(this.locked.planck, this.reserved.planck);
     const baseUnavailable = this.#storage.useLegacyTransferableCalculation ? oldCalculation() : newCalculation();
     const nomPoolStakedPlancks = this.locks.some(
       (lock) => lock.source === "substrate-native-holds" && lock.label === "DelegatedStaking"
@@ -3830,8 +4331,8 @@ var Balance = class {
   /** The feePayable balance of this token. Is generally the free amount - the feeFrozen amount. */
   get feePayable() {
     if (this.locks.length === 0) return this.free;
-    const excludeAmount = excludeFromFeePayableLocks(this.locked.planck.toString()).map((lock) => BigInt(lock.amount)).reduce((max, lock) => import_util6.BigMath.max(max, lock), 0n);
-    return this.#format(import_util6.BigMath.max(this.free.planck - excludeAmount, 0n));
+    const excludeAmount = excludeFromFeePayableLocks(this.locked.planck.toString()).map((lock) => BigInt(lock.amount)).reduce((max, lock) => import_util7.BigMath.max(max, lock), 0n);
+    return this.#format(import_util7.BigMath.max(this.free.planck - excludeAmount, 0n));
   }
 };
 var BalanceValueGetter = class {
@@ -3854,7 +4355,7 @@ var BalanceFormatter = class {
   #decimals;
   #tokenRates;
   constructor(planck, decimals, fiatRatios) {
-    this.#planck = (0, import_util6.isBigInt)(planck) ? planck.toString() : planck ?? "0";
+    this.#planck = (0, import_util7.isBigInt)(planck) ? planck.toString() : planck ?? "0";
     this.#decimals = decimals || 0;
     this.#tokenRates = fiatRatios || null;
   }
@@ -3863,7 +4364,7 @@ var BalanceFormatter = class {
     return BigInt(this.#planck);
   }
   get tokens() {
-    return (0, import_util6.planckToTokens)(this.#planck, this.#decimals);
+    return (0, import_util7.planckToTokens)(this.#planck, this.#decimals);
   }
   fiat(currency) {
     if (!this.#tokenRates) return null;
@@ -4057,23 +4558,23 @@ var getValueId = (amount) => {
 };
 
 // src/types/minimetadatas.ts
-var import_chaindata_provider36 = require("@talismn/chaindata-provider");
+var import_chaindata_provider43 = require("@talismn/chaindata-provider");
 var import_scale10 = require("@talismn/scale");
 var deriveMiniMetadataId = ({
   source,
   chainId,
   specVersion
 }) => (0, import_scale10.toHex)(
-  (0, import_scale10.Twox128)(new TextEncoder().encode(`${source}${chainId}${specVersion}${import_chaindata_provider36.MINIMETADATA_VERSION}`))
+  (0, import_scale10.Twox128)(new TextEncoder().encode(`${source}${chainId}${specVersion}${import_chaindata_provider43.MINIMETADATA_VERSION}`))
 ).slice(-32);
 
 // src/modules/substrate-assets/getMiniMetadata.ts
-var getMiniMetadata7 = ({
+var getMiniMetadata8 = ({
   networkId,
   specVersion,
   metadataRpc
 }) => {
-  const source = MODULE_TYPE6;
+  const source = MODULE_TYPE7;
   const chainId = networkId;
   const systemVersion = getConstantValue(metadataRpc, "System", "Version");
   if (specVersion !== systemVersion.spec_version)
@@ -4091,7 +4592,7 @@ var getMiniMetadata7 = ({
     source,
     chainId,
     specVersion,
-    version: import_chaindata_provider37.MINIMETADATA_VERSION,
+    version: import_chaindata_provider44.MINIMETADATA_VERSION,
     data: getData2(metadataRpc),
     extra: null
   };
@@ -4105,10 +4606,10 @@ var getData2 = (metadataRpc) => {
 
 // src/modules/substrate-assets/getTransferCallData.ts
 var import_utils4 = require("@polkadot-api/utils");
-var import_chaindata_provider38 = require("@talismn/chaindata-provider");
+var import_chaindata_provider45 = require("@talismn/chaindata-provider");
 var import_scale12 = require("@talismn/scale");
 var import_polkadot_api2 = require("polkadot-api");
-var getTransferCallData7 = ({
+var getTransferCallData8 = ({
   from: from2,
   to,
   value,
@@ -4116,8 +4617,8 @@ var getTransferCallData7 = ({
   type,
   metadataRpc
 }) => {
-  if (!(0, import_chaindata_provider38.isTokenOfType)(token, MODULE_TYPE6))
-    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE6}.`);
+  if (!(0, import_chaindata_provider45.isTokenOfType)(token, MODULE_TYPE7))
+    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE7}.`);
   const { builder } = (0, import_scale12.parseMetadataRpc)(metadataRpc);
   const method = getTransferMethod(type);
   const { codec, location } = builder.buildCall("Assets", method);
@@ -4206,18 +4707,18 @@ var getTransferAllEncodedArgs = (assetId, to, codec) => {
 };
 
 // src/modules/substrate-assets/subscribeBalances.ts
-var import_rxjs9 = require("rxjs");
-var subscribeBalances7 = ({
+var import_rxjs10 = require("rxjs");
+var subscribeBalances8 = ({
   networkId,
   tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
-  if (!tokensWithAddresses.length) return (0, import_rxjs9.of)({ success: [], errors: [] });
+  if (!tokensWithAddresses.length) return (0, import_rxjs10.of)({ success: [], errors: [] });
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   const queries = buildQueries(networkId, balanceDefs, miniMetadata);
   return getRpcQueryPack$(connector, networkId, queries).pipe(
-    (0, import_rxjs9.map)((balances) => ({
+    (0, import_rxjs10.map)((balances) => ({
       success: balances,
       errors: []
     }))
@@ -4226,31 +4727,31 @@ var subscribeBalances7 = ({
 
 // src/modules/substrate-assets/module.ts
 var SubAssetsBalanceModule = {
-  type: MODULE_TYPE6,
-  platform: PLATFORM6,
-  getMiniMetadata: getMiniMetadata7,
-  fetchTokens: fetchTokens6,
-  fetchBalances: fetchBalances6,
-  subscribeBalances: subscribeBalances7,
-  getTransferCallData: getTransferCallData7
+  type: MODULE_TYPE7,
+  platform: PLATFORM7,
+  getMiniMetadata: getMiniMetadata8,
+  fetchTokens: fetchTokens7,
+  fetchBalances: fetchBalances7,
+  subscribeBalances: subscribeBalances8,
+  getTransferCallData: getTransferCallData8
 };
 
 // src/modules/substrate-assets/types.ts
-var import_chaindata_provider39 = require("@talismn/chaindata-provider");
-var import_v410 = __toESM(require("zod/v4"));
-var SubAssetsTokenConfigSchema = import_v410.default.strictObject({
-  assetId: import_chaindata_provider39.SubAssetsTokenSchema.shape.assetId,
+var import_chaindata_provider46 = require("@talismn/chaindata-provider");
+var import_v412 = __toESM(require("zod/v4"));
+var SubAssetsTokenConfigSchema = import_v412.default.strictObject({
+  assetId: import_chaindata_provider46.SubAssetsTokenSchema.shape.assetId,
   ...TokenConfigBaseSchema.shape
 });
 
 // src/modules/substrate-foreignassets/config.ts
-var import_chaindata_provider40 = require("@talismn/chaindata-provider");
-var MODULE_TYPE8 = import_chaindata_provider40.SubForeignAssetsTokenSchema.shape.type.value;
-var PLATFORM8 = import_chaindata_provider40.SubForeignAssetsTokenSchema.shape.platform.value;
+var import_chaindata_provider47 = require("@talismn/chaindata-provider");
+var MODULE_TYPE9 = import_chaindata_provider47.SubForeignAssetsTokenSchema.shape.type.value;
+var PLATFORM9 = import_chaindata_provider47.SubForeignAssetsTokenSchema.shape.platform.value;
 
 // src/modules/substrate-foreignassets/buildQueries.ts
 var import_scale13 = require("@talismn/scale");
-var import_util7 = require("@talismn/util");
+var import_util8 = require("@talismn/util");
 var buildQueries2 = (networkId, balanceDefs, miniMetadata) => {
   const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
     storage: ["ForeignAssets", "Account"]
@@ -4305,11 +4806,11 @@ var buildQueries2 = (networkId, balanceDefs, miniMetadata) => {
       stateKeys: [stateKey],
       decodeResult
     };
-  }).filter(import_util7.isNotNil);
+  }).filter(import_util8.isNotNil);
 };
 
 // src/modules/substrate-foreignassets/fetchBalances.ts
-var fetchBalances8 = async ({
+var fetchBalances9 = async ({
   networkId,
   tokensWithAddresses,
   connector,
@@ -4318,7 +4819,7 @@ var fetchBalances8 = async ({
   if (!tokensWithAddresses.length) return { success: [], errors: [] };
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!miniMetadata?.data) {
-    log_default.warn(`MiniMetadata is required for fetching ${MODULE_TYPE8} balances on ${networkId}.`);
+    log_default.warn(`MiniMetadata is required for fetching ${MODULE_TYPE9} balances on ${networkId}.`);
     return {
       success: [],
       errors: balanceDefs.map((def) => ({
@@ -4328,20 +4829,20 @@ var fetchBalances8 = async ({
       }))
     };
   }
-  if (miniMetadata.source !== MODULE_TYPE8) {
-    log_default.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE8}.`);
+  if (miniMetadata.source !== MODULE_TYPE9) {
+    log_default.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE9}.`);
     return {
       success: [],
       errors: balanceDefs.map((def) => ({
         tokenId: def.token.id,
         address: def.address,
-        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE8}`)
+        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE9}`)
       }))
     };
   }
   if (miniMetadata.chainId !== networkId) {
     log_default.warn(
-      `Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE8}. Expected chainId is ${networkId}`
+      `Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE9}. Expected chainId is ${networkId}`
     );
     return {
       success: [],
@@ -4365,7 +4866,7 @@ var fetchBalances8 = async ({
           address: def.address,
           networkId,
           tokenId: def.token.id,
-          source: MODULE_TYPE8,
+          source: MODULE_TYPE9,
           status: "live",
           values: [
             { type: "free", label: "free", amount: "0" },
@@ -4379,10 +4880,10 @@ var fetchBalances8 = async ({
 };
 
 // src/modules/substrate-foreignassets/fetchTokens.ts
-var import_chaindata_provider41 = require("@talismn/chaindata-provider");
+var import_chaindata_provider48 = require("@talismn/chaindata-provider");
 var import_scale14 = require("@talismn/scale");
-var import_lodash_es19 = require("lodash-es");
-var fetchTokens8 = async ({
+var import_lodash_es22 = require("lodash-es");
+var fetchTokens9 = async ({
   networkId,
   tokens,
   connector,
@@ -4407,7 +4908,7 @@ var fetchTokens8 = async ({
   ]);
   const assetStorageEntries = assetStorageResults[0]?.changes ?? [];
   const metadataStorageEntries = metadataStorageResults[0]?.changes ?? [];
-  const assetByOnChainId = (0, import_lodash_es19.keyBy)(
+  const assetByOnChainId = (0, import_lodash_es22.keyBy)(
     assetStorageEntries.map(([key, value]) => {
       const [decodedKey] = assetCodec.keys.dec(key);
       const onChainId = (0, import_scale14.papiStringify)(decodedKey);
@@ -4416,7 +4917,7 @@ var fetchTokens8 = async ({
     }),
     (a) => a.onChainId
   );
-  const metadataByOnChainId = (0, import_lodash_es19.keyBy)(
+  const metadataByOnChainId = (0, import_lodash_es22.keyBy)(
     metadataStorageEntries.map(([key, value]) => {
       const [decodedKey] = metadataCodec.keys.dec(key);
       const onChainId = (0, import_scale14.papiStringify)(decodedKey);
@@ -4431,14 +4932,14 @@ var fetchTokens8 = async ({
     }),
     (a) => a.onChainId
   );
-  const allTokens = (0, import_lodash_es19.keys)(assetByOnChainId).map(
-    (onChainId) => (0, import_lodash_es19.assign)({}, assetByOnChainId[onChainId], metadataByOnChainId[onChainId] ?? void 0)
+  const allTokens = (0, import_lodash_es22.keys)(assetByOnChainId).map(
+    (onChainId) => (0, import_lodash_es22.assign)({}, assetByOnChainId[onChainId], metadataByOnChainId[onChainId] ?? void 0)
   );
-  const configTokenByOnChainId = (0, import_lodash_es19.keyBy)(tokens, (t) => t.onChainId);
+  const configTokenByOnChainId = (0, import_lodash_es22.keyBy)(tokens, (t) => t.onChainId);
   return allTokens.map(
     (asset) => ({
-      id: (0, import_chaindata_provider41.subForeignAssetTokenId)(networkId, asset.onChainId),
-      type: MODULE_TYPE8,
+      id: (0, import_chaindata_provider48.subForeignAssetTokenId)(networkId, asset.onChainId),
+      type: MODULE_TYPE9,
       platform: "polkadot",
       networkId,
       onChainId: String(asset.onChainId),
@@ -4455,22 +4956,22 @@ var fetchTokens8 = async ({
     return configToken || token.isSufficient;
   }).map((token) => {
     const configToken = configTokenByOnChainId[token.onChainId];
-    return configToken ? (0, import_lodash_es19.assign)({}, token, configToken) : token;
+    return configToken ? (0, import_lodash_es22.assign)({}, token, configToken) : token;
   }).filter((t) => {
-    const parsed = import_chaindata_provider41.SubForeignAssetsTokenSchema.safeParse(t);
+    const parsed = import_chaindata_provider48.SubForeignAssetsTokenSchema.safeParse(t);
     return parsed.success;
   });
 };
 
 // src/modules/substrate-foreignassets/getMiniMetadata.ts
-var import_chaindata_provider42 = require("@talismn/chaindata-provider");
+var import_chaindata_provider49 = require("@talismn/chaindata-provider");
 var import_scale15 = require("@talismn/scale");
-var getMiniMetadata8 = ({
+var getMiniMetadata9 = ({
   networkId,
   specVersion,
   metadataRpc
 }) => {
-  const source = MODULE_TYPE8;
+  const source = MODULE_TYPE9;
   const chainId = networkId;
   const systemVersion = getConstantValue(metadataRpc, "System", "Version");
   if (specVersion !== systemVersion.spec_version)
@@ -4488,7 +4989,7 @@ var getMiniMetadata8 = ({
     source,
     chainId,
     specVersion,
-    version: import_chaindata_provider42.MINIMETADATA_VERSION,
+    version: import_chaindata_provider49.MINIMETADATA_VERSION,
     data: getData3(metadataRpc),
     extra: null
   };
@@ -4503,10 +5004,10 @@ var getData3 = (metadataRpc) => {
 
 // src/modules/substrate-foreignassets/getTransferCallData.ts
 var import_utils5 = require("@polkadot-api/utils");
-var import_chaindata_provider43 = require("@talismn/chaindata-provider");
+var import_chaindata_provider50 = require("@talismn/chaindata-provider");
 var import_scale16 = require("@talismn/scale");
 var import_polkadot_api3 = require("polkadot-api");
-var getTransferCallData8 = ({
+var getTransferCallData9 = ({
   from: from2,
   to,
   value,
@@ -4514,8 +5015,8 @@ var getTransferCallData8 = ({
   type,
   metadataRpc
 }) => {
-  if (!(0, import_chaindata_provider43.isTokenOfType)(token, MODULE_TYPE8))
-    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE8}.`);
+  if (!(0, import_chaindata_provider50.isTokenOfType)(token, MODULE_TYPE9))
+    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE9}.`);
   const { builder } = (0, import_scale16.parseMetadataRpc)(metadataRpc);
   const method = getTransferMethod2(type);
   const { codec, location } = builder.buildCall("ForeignAssets", method);
@@ -4594,18 +5095,18 @@ var getTransferAllEncodedArgs2 = (onChainId, to, codec) => {
 };
 
 // src/modules/substrate-foreignassets/subscribeBalances.ts
-var import_rxjs10 = require("rxjs");
-var subscribeBalances8 = ({
+var import_rxjs11 = require("rxjs");
+var subscribeBalances9 = ({
   networkId,
   tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
-  if (!tokensWithAddresses.length) return (0, import_rxjs10.of)({ success: [], errors: [] });
+  if (!tokensWithAddresses.length) return (0, import_rxjs11.of)({ success: [], errors: [] });
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   const queries = buildQueries2(networkId, balanceDefs, miniMetadata);
   return getRpcQueryPack$(connector, networkId, queries).pipe(
-    (0, import_rxjs10.map)((balances) => ({
+    (0, import_rxjs11.map)((balances) => ({
       success: balances,
       errors: []
     }))
@@ -4614,31 +5115,31 @@ var subscribeBalances8 = ({
 
 // src/modules/substrate-foreignassets/module.ts
 var SubForeignAssetsBalanceModule = {
-  type: MODULE_TYPE8,
-  platform: PLATFORM8,
-  getMiniMetadata: getMiniMetadata8,
-  fetchTokens: fetchTokens8,
-  fetchBalances: fetchBalances8,
-  subscribeBalances: subscribeBalances8,
-  getTransferCallData: getTransferCallData8
+  type: MODULE_TYPE9,
+  platform: PLATFORM9,
+  getMiniMetadata: getMiniMetadata9,
+  fetchTokens: fetchTokens9,
+  fetchBalances: fetchBalances9,
+  subscribeBalances: subscribeBalances9,
+  getTransferCallData: getTransferCallData9
 };
 
 // src/modules/substrate-foreignassets/types.ts
-var import_chaindata_provider44 = require("@talismn/chaindata-provider");
-var import_v411 = __toESM(require("zod/v4"));
-var SubForeignAssetsTokenConfigSchema = import_v411.default.strictObject({
-  onChainId: import_chaindata_provider44.SubForeignAssetsTokenSchema.shape.onChainId,
+var import_chaindata_provider51 = require("@talismn/chaindata-provider");
+var import_v413 = __toESM(require("zod/v4"));
+var SubForeignAssetsTokenConfigSchema = import_v413.default.strictObject({
+  onChainId: import_chaindata_provider51.SubForeignAssetsTokenSchema.shape.onChainId,
   ...TokenConfigBaseSchema.shape
 });
 
 // src/modules/substrate-hydration/config.ts
-var import_chaindata_provider45 = require("@talismn/chaindata-provider");
-var MODULE_TYPE9 = import_chaindata_provider45.SubHydrationTokenSchema.shape.type.value;
-var PLATFORM9 = import_chaindata_provider45.SubHydrationTokenSchema.shape.platform.value;
+var import_chaindata_provider52 = require("@talismn/chaindata-provider");
+var MODULE_TYPE10 = import_chaindata_provider52.SubHydrationTokenSchema.shape.type.value;
+var PLATFORM10 = import_chaindata_provider52.SubHydrationTokenSchema.shape.platform.value;
 
 // src/modules/substrate-hydration/fetchBalances.ts
-var import_lodash_es20 = require("lodash-es");
-var fetchBalances9 = async ({
+var import_lodash_es23 = require("lodash-es");
+var fetchBalances10 = async ({
   networkId,
   tokensWithAddresses,
   connector,
@@ -4647,7 +5148,7 @@ var fetchBalances9 = async ({
   if (!tokensWithAddresses.length) return { success: [], errors: [] };
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!miniMetadata?.data) {
-    log_default.warn(`MiniMetadata is required for fetching ${MODULE_TYPE9} balances on ${networkId}.`, {
+    log_default.warn(`MiniMetadata is required for fetching ${MODULE_TYPE10} balances on ${networkId}.`, {
       tokensWithAddresses
     });
     return {
@@ -4659,20 +5160,20 @@ var fetchBalances9 = async ({
       }))
     };
   }
-  if (miniMetadata.source !== MODULE_TYPE9) {
-    log_default.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE9}.`);
+  if (miniMetadata.source !== MODULE_TYPE10) {
+    log_default.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE10}.`);
     return {
       success: [],
       errors: balanceDefs.map((def) => ({
         tokenId: def.token.id,
         address: def.address,
-        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE9}`)
+        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE10}`)
       }))
     };
   }
   if (miniMetadata.chainId !== networkId) {
     log_default.warn(
-      `Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE9}. Expected chainId is ${networkId}`
+      `Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE10}. Expected chainId is ${networkId}`
     );
     return {
       success: [],
@@ -4683,7 +5184,7 @@ var fetchBalances9 = async ({
       }))
     };
   }
-  const addresses = (0, import_lodash_es20.uniq)(balanceDefs.map((def) => def.address));
+  const addresses = (0, import_lodash_es23.uniq)(balanceDefs.map((def) => def.address));
   try {
     const res = await Promise.all(
       addresses.map(
@@ -4699,16 +5200,16 @@ var fetchBalances9 = async ({
         frozen: balance.frozen.toString()
       })).filter((b) => b.onChainId !== void 0);
     });
-    const balancesByKey = (0, import_lodash_es20.keyBy)(fetchedBalances, (b) => `${b.address}:${b.onChainId}`);
+    const balancesByKey = (0, import_lodash_es23.keyBy)(fetchedBalances, (b) => `${b.address}:${b.onChainId}`);
     const success = tokensWithAddresses.reduce((acc, [token, addresses2]) => {
-      if (token.type === MODULE_TYPE9)
+      if (token.type === MODULE_TYPE10)
         for (const address of addresses2) {
           const rawBalance = balancesByKey[`${address}:${token.onChainId}`];
           const balance = {
             address,
             networkId,
             tokenId: token.id,
-            source: MODULE_TYPE9,
+            source: MODULE_TYPE10,
             status: "live",
             values: [
               {
@@ -4751,10 +5252,10 @@ var fetchBalances9 = async ({
 };
 
 // src/modules/substrate-hydration/fetchTokens.ts
-var import_chaindata_provider46 = require("@talismn/chaindata-provider");
+var import_chaindata_provider53 = require("@talismn/chaindata-provider");
 var import_scale17 = require("@talismn/scale");
-var import_lodash_es21 = require("lodash-es");
-var fetchTokens9 = async ({
+var import_lodash_es24 = require("lodash-es");
+var fetchTokens10 = async ({
   networkId,
   tokens,
   connector,
@@ -4773,7 +5274,7 @@ var fetchTokens9 = async ({
     [allAssetStorageKeys]
   );
   const assetStorageEntries = assetStorageResults.length ? assetStorageResults[0].changes : [];
-  const configTokenByAssetId = (0, import_lodash_es21.keyBy)(tokens, (t) => t.onChainId);
+  const configTokenByAssetId = (0, import_lodash_es24.keyBy)(tokens, (t) => t.onChainId);
   return assetStorageEntries.map(([key, value]) => {
     const [onChainId] = assetsCodec.keys.dec(key);
     const asset = assetsCodec.value.dec(value);
@@ -4788,8 +5289,8 @@ var fetchTokens9 = async ({
     };
   }).map(
     (asset) => ({
-      id: (0, import_chaindata_provider46.subHydrationTokenId)(networkId, asset.onChainId),
-      type: MODULE_TYPE9,
+      id: (0, import_chaindata_provider53.subHydrationTokenId)(networkId, asset.onChainId),
+      type: MODULE_TYPE10,
       platform: "polkadot",
       networkId,
       onChainId: asset.onChainId,
@@ -4807,22 +5308,22 @@ var fetchTokens9 = async ({
     return configToken || token.isSufficient;
   }).map((token) => {
     const configToken = configTokenByAssetId[token.onChainId];
-    return configToken ? (0, import_lodash_es21.assign)({}, token, configToken) : token;
+    return configToken ? (0, import_lodash_es24.assign)({}, token, configToken) : token;
   }).filter((t) => {
-    const parsed = import_chaindata_provider46.SubHydrationTokenSchema.safeParse(t);
+    const parsed = import_chaindata_provider53.SubHydrationTokenSchema.safeParse(t);
     return parsed.success;
   });
 };
 
 // src/modules/substrate-hydration/getMiniMetadata.ts
-var import_chaindata_provider47 = require("@talismn/chaindata-provider");
+var import_chaindata_provider54 = require("@talismn/chaindata-provider");
 var import_scale18 = require("@talismn/scale");
-var getMiniMetadata9 = ({
+var getMiniMetadata10 = ({
   networkId,
   specVersion,
   metadataRpc
 }) => {
-  const source = MODULE_TYPE9;
+  const source = MODULE_TYPE10;
   const chainId = networkId;
   const systemVersion = getConstantValue(metadataRpc, "System", "Version");
   if (specVersion !== systemVersion.spec_version)
@@ -4840,7 +5341,7 @@ var getMiniMetadata9 = ({
     source,
     chainId,
     specVersion,
-    version: import_chaindata_provider47.MINIMETADATA_VERSION,
+    version: import_chaindata_provider54.MINIMETADATA_VERSION,
     data: getData4(metadataRpc),
     extra: null
   };
@@ -4869,18 +5370,18 @@ var getData4 = (metadataRpc) => {
 
 // src/modules/substrate-hydration/getTransferCallData.ts
 var import_utils6 = require("@polkadot-api/utils");
-var import_chaindata_provider48 = require("@talismn/chaindata-provider");
+var import_chaindata_provider55 = require("@talismn/chaindata-provider");
 var import_scale19 = require("@talismn/scale");
 var import_polkadot_api4 = require("polkadot-api");
-var getTransferCallData9 = ({
+var getTransferCallData10 = ({
   from: from2,
   to,
   value,
   token,
   metadataRpc
 }) => {
-  if (!(0, import_chaindata_provider48.isTokenOfType)(token, MODULE_TYPE9))
-    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE9}.`);
+  if (!(0, import_chaindata_provider55.isTokenOfType)(token, MODULE_TYPE10))
+    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE10}.`);
   const { builder } = (0, import_scale19.parseMetadataRpc)(metadataRpc);
   const { codec, location } = builder.buildCall("Currencies", "transfer");
   const args = {
@@ -4896,22 +5397,22 @@ var getTransferCallData9 = ({
 };
 
 // src/modules/substrate-hydration/subscribeBalances.ts
-var import_lodash_es22 = require("lodash-es");
-var import_rxjs11 = require("rxjs");
-var SUBSCRIPTION_INTERVAL7 = 6e3;
-var subscribeBalances9 = ({
+var import_lodash_es25 = require("lodash-es");
+var import_rxjs12 = require("rxjs");
+var SUBSCRIPTION_INTERVAL8 = 6e3;
+var subscribeBalances10 = ({
   networkId,
   tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
-  if (!tokensWithAddresses.length) return (0, import_rxjs11.of)({ success: [], errors: [] });
-  return new import_rxjs11.Observable((subscriber) => {
+  if (!tokensWithAddresses.length) return (0, import_rxjs12.of)({ success: [], errors: [] });
+  return new import_rxjs12.Observable((subscriber) => {
     const abortController = new AbortController();
     const poll = async () => {
       try {
         if (abortController.signal.aborted) return;
-        const balances = await fetchBalances9({
+        const balances = await fetchBalances10({
           networkId,
           tokensWithAddresses,
           connector,
@@ -4919,10 +5420,10 @@ var subscribeBalances9 = ({
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL7);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL8);
       } catch (error) {
         log_default.error("Error", {
-          module: MODULE_TYPE9,
+          module: MODULE_TYPE10,
           networkId,
           miniMetadata,
           addressesByToken: tokensWithAddresses,
@@ -4935,36 +5436,36 @@ var subscribeBalances9 = ({
     return () => {
       abortController.abort();
     };
-  }).pipe((0, import_rxjs11.distinctUntilChanged)(import_lodash_es22.isEqual));
+  }).pipe((0, import_rxjs12.distinctUntilChanged)(import_lodash_es25.isEqual));
 };
 
 // src/modules/substrate-hydration/module.ts
 var SubHydrationBalanceModule = {
-  type: MODULE_TYPE9,
-  platform: PLATFORM9,
-  getMiniMetadata: getMiniMetadata9,
-  fetchTokens: fetchTokens9,
-  fetchBalances: fetchBalances9,
-  subscribeBalances: subscribeBalances9,
-  getTransferCallData: getTransferCallData9
+  type: MODULE_TYPE10,
+  platform: PLATFORM10,
+  getMiniMetadata: getMiniMetadata10,
+  fetchTokens: fetchTokens10,
+  fetchBalances: fetchBalances10,
+  subscribeBalances: subscribeBalances10,
+  getTransferCallData: getTransferCallData10
 };
 
 // src/modules/substrate-hydration/types.ts
-var import_chaindata_provider49 = require("@talismn/chaindata-provider");
-var import_v412 = __toESM(require("zod/v4"));
-var SubHydrationTokenConfigSchema = import_v412.default.strictObject({
-  onChainId: import_chaindata_provider49.SubHydrationTokenSchema.shape.onChainId,
+var import_chaindata_provider56 = require("@talismn/chaindata-provider");
+var import_v414 = __toESM(require("zod/v4"));
+var SubHydrationTokenConfigSchema = import_v414.default.strictObject({
+  onChainId: import_chaindata_provider56.SubHydrationTokenSchema.shape.onChainId,
   ...TokenConfigBaseSchema.shape
 });
 
 // src/modules/substrate-native/config.ts
-var import_chaindata_provider50 = require("@talismn/chaindata-provider");
-var MODULE_TYPE10 = import_chaindata_provider50.SubNativeTokenSchema.shape.type.value;
-var PLATFORM10 = import_chaindata_provider50.SubNativeTokenSchema.shape.platform.value;
+var import_chaindata_provider57 = require("@talismn/chaindata-provider");
+var MODULE_TYPE11 = import_chaindata_provider57.SubNativeTokenSchema.shape.type.value;
+var PLATFORM11 = import_chaindata_provider57.SubNativeTokenSchema.shape.platform.value;
 
 // src/modules/substrate-native/queries/buildBaseQueries.ts
 var import_scale20 = require("@talismn/scale");
-var import_util8 = require("@talismn/util");
+var import_util9 = require("@talismn/util");
 
 // src/modules/substrate-native/util/lockTypes.ts
 var import_upperFirst = __toESM(require("lodash-es/upperFirst"));
@@ -5125,7 +5626,7 @@ var buildBaseQueries = (networkId, balanceDefs, miniMetadata) => {
         return { balance, nomPoolMemberInfo };
       }
     };
-  }).filter(import_util8.isNotNil);
+  }).filter(import_util9.isNotNil);
 };
 var decodeBaseResult = (coder, value, networkId) => {
   const decoded = (0, import_scale20.decodeScale)(
@@ -5365,11 +5866,11 @@ var getNomPoolStateKeys = (coders, nomPoolMemberInfo, extra) => {
 };
 
 // src/modules/substrate-native/fetchBalances.ts
-var fetchBalances10 = async ({ networkId, tokensWithAddresses, connector, miniMetadata }) => {
+var fetchBalances11 = async ({ networkId, tokensWithAddresses, connector, miniMetadata }) => {
   if (!tokensWithAddresses.length) return { success: [], errors: [] };
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!miniMetadata?.data) {
-    log_default.warn(`MiniMetadata is required for fetching ${MODULE_TYPE10} balances on ${networkId}.`);
+    log_default.warn(`MiniMetadata is required for fetching ${MODULE_TYPE11} balances on ${networkId}.`);
     return {
       success: [],
       errors: balanceDefs.map((def) => ({
@@ -5379,20 +5880,20 @@ var fetchBalances10 = async ({ networkId, tokensWithAddresses, connector, miniMe
       }))
     };
   }
-  if (miniMetadata.source !== MODULE_TYPE10) {
-    log_default.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE10}.`);
+  if (miniMetadata.source !== MODULE_TYPE11) {
+    log_default.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE11}.`);
     return {
       success: [],
       errors: balanceDefs.map((def) => ({
         tokenId: def.token.id,
         address: def.address,
-        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE10}`)
+        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE11}`)
       }))
     };
   }
   if (miniMetadata.chainId !== networkId) {
     log_default.warn(
-      `Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE10}. Expected chainId is ${networkId}`
+      `Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE11}. Expected chainId is ${networkId}`
     );
     return {
       success: [],
@@ -5411,10 +5912,10 @@ var fetchBalances10 = async ({ networkId, tokensWithAddresses, connector, miniMe
 };
 
 // src/modules/substrate-native/fetchTokens.ts
-var import_chaindata_provider51 = require("@talismn/chaindata-provider");
-var import_lodash_es23 = require("lodash-es");
-var import_v413 = __toESM(require("zod/v4"));
-var fetchTokens10 = async ({ networkId, tokens, connector, miniMetadata }) => {
+var import_chaindata_provider58 = require("@talismn/chaindata-provider");
+var import_lodash_es26 = require("lodash-es");
+var import_v415 = __toESM(require("zod/v4"));
+var fetchTokens11 = async ({ networkId, tokens, connector, miniMetadata }) => {
   if (miniMetadata.extra.disable) return [];
   const { tokenSymbol: symbol, tokenDecimals: decimals } = await getChainProperties(
     connector,
@@ -5424,7 +5925,7 @@ var fetchTokens10 = async ({ networkId, tokens, connector, miniMetadata }) => {
     log_default.warn(`Substrate native module: existentialDeposit is undefined for ${networkId}, using 0`);
   const tokenConfig = tokens[0];
   const nativeToken = {
-    id: (0, import_chaindata_provider51.subNativeTokenId)(networkId),
+    id: (0, import_chaindata_provider58.subNativeTokenId)(networkId),
     type: "substrate-native",
     platform: "polkadot",
     networkId,
@@ -5434,22 +5935,22 @@ var fetchTokens10 = async ({ networkId, tokens, connector, miniMetadata }) => {
     decimals,
     existentialDeposit: miniMetadata.extra.existentialDeposit ?? "0"
   };
-  const token = (0, import_lodash_es23.assign)(nativeToken, tokenConfig);
-  const parsed = import_chaindata_provider51.SubNativeTokenSchema.safeParse(token);
+  const token = (0, import_lodash_es26.assign)(nativeToken, tokenConfig);
+  const parsed = import_chaindata_provider58.SubNativeTokenSchema.safeParse(token);
   if (!parsed.success) {
     return [];
   }
   return [parsed.data];
 };
-var DotNetworkPropertiesSimple = import_v413.default.object({
-  tokenDecimals: import_v413.default.number().optional().default(0),
-  tokenSymbol: import_v413.default.string().optional().default("Unit")
+var DotNetworkPropertiesSimple = import_v415.default.object({
+  tokenDecimals: import_v415.default.number().optional().default(0),
+  tokenSymbol: import_v415.default.string().optional().default("Unit")
 });
-var DotNetworkPropertiesArray = import_v413.default.object({
-  tokenDecimals: import_v413.default.array(import_v413.default.number()).nonempty(),
-  tokenSymbol: import_v413.default.array(import_v413.default.string()).nonempty()
+var DotNetworkPropertiesArray = import_v415.default.object({
+  tokenDecimals: import_v415.default.array(import_v415.default.number()).nonempty(),
+  tokenSymbol: import_v415.default.array(import_v415.default.string()).nonempty()
 });
-var DotNetworkPropertiesSchema = import_v413.default.union([DotNetworkPropertiesSimple, DotNetworkPropertiesArray]).transform((val) => ({
+var DotNetworkPropertiesSchema = import_v415.default.union([DotNetworkPropertiesSimple, DotNetworkPropertiesArray]).transform((val) => ({
   tokenDecimals: Array.isArray(val.tokenDecimals) ? val.tokenDecimals[0] : val.tokenDecimals,
   tokenSymbol: Array.isArray(val.tokenSymbol) ? val.tokenSymbol[0] : val.tokenSymbol
 }));
@@ -5459,10 +5960,10 @@ var getChainProperties = async (connector, networkId) => {
 };
 
 // src/modules/substrate-native/getMiniMetadata.ts
-var import_chaindata_provider52 = require("@talismn/chaindata-provider");
+var import_chaindata_provider59 = require("@talismn/chaindata-provider");
 var import_scale22 = require("@talismn/scale");
-var getMiniMetadata10 = ({ networkId, specVersion, metadataRpc, config }) => {
-  const source = MODULE_TYPE10;
+var getMiniMetadata11 = ({ networkId, specVersion, metadataRpc, config }) => {
+  const source = MODULE_TYPE11;
   const chainId = networkId;
   const systemVersion = getConstantValue(metadataRpc, "System", "Version");
   if (specVersion !== systemVersion.spec_version)
@@ -5481,7 +5982,7 @@ var getMiniMetadata10 = ({ networkId, specVersion, metadataRpc, config }) => {
       source,
       chainId,
       specVersion,
-      version: import_chaindata_provider52.MINIMETADATA_VERSION,
+      version: import_chaindata_provider59.MINIMETADATA_VERSION,
       data: null,
       extra: { disable: true }
     };
@@ -5510,7 +6011,7 @@ var getMiniMetadata10 = ({ networkId, specVersion, metadataRpc, config }) => {
     source,
     chainId,
     specVersion,
-    version: import_chaindata_provider52.MINIMETADATA_VERSION,
+    version: import_chaindata_provider59.MINIMETADATA_VERSION,
     data: (0, import_scale22.encodeMetadata)(metadata),
     extra: {
       useLegacyTransferableCalculation,
@@ -5522,10 +6023,10 @@ var getMiniMetadata10 = ({ networkId, specVersion, metadataRpc, config }) => {
 
 // src/modules/substrate-native/getTransferCallData.ts
 var import_utils8 = require("@polkadot-api/utils");
-var import_chaindata_provider53 = require("@talismn/chaindata-provider");
+var import_chaindata_provider60 = require("@talismn/chaindata-provider");
 var import_scale23 = require("@talismn/scale");
 var import_polkadot_api6 = require("polkadot-api");
-var getTransferCallData10 = ({
+var getTransferCallData11 = ({
   from: from2,
   to,
   value,
@@ -5533,8 +6034,8 @@ var getTransferCallData10 = ({
   type,
   metadataRpc
 }) => {
-  if (!(0, import_chaindata_provider53.isTokenOfType)(token, MODULE_TYPE10))
-    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE10}.`);
+  if (!(0, import_chaindata_provider60.isTokenOfType)(token, MODULE_TYPE11))
+    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE11}.`);
   const { unifiedMetadata, lookupFn, builder } = (0, import_scale23.parseMetadataRpc)(metadataRpc);
   const method = getTransferMethod3(type, unifiedMetadata, lookupFn);
   const { codec, location } = builder.buildCall("Balances", method);
@@ -5612,17 +6113,17 @@ var getTransferAllEncodedArgs3 = (to, codec) => {
 };
 
 // src/modules/substrate-native/subscribeBalances.ts
-var import_rxjs12 = require("rxjs");
-var subscribeBalances10 = ({ networkId, tokensWithAddresses, connector, miniMetadata }) => {
-  if (!tokensWithAddresses.length) return (0, import_rxjs12.of)({ success: [], errors: [] });
+var import_rxjs13 = require("rxjs");
+var subscribeBalances11 = ({ networkId, tokensWithAddresses, connector, miniMetadata }) => {
+  if (!tokensWithAddresses.length) return (0, import_rxjs13.of)({ success: [], errors: [] });
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   const baseQueries = buildBaseQueries(networkId, balanceDefs, miniMetadata);
   return getRpcQueryPack$(connector, networkId, baseQueries).pipe(
-    (0, import_rxjs12.switchMap)((partialBalances) => {
+    (0, import_rxjs13.switchMap)((partialBalances) => {
       const nomPoolQueries = buildNomPoolQueries(networkId, partialBalances, miniMetadata);
       return getRpcQueryPack$(connector, networkId, nomPoolQueries);
     }),
-    (0, import_rxjs12.map)((balances) => ({
+    (0, import_rxjs13.map)((balances) => ({
       success: balances,
       errors: []
     }))
@@ -5631,34 +6132,34 @@ var subscribeBalances10 = ({ networkId, tokensWithAddresses, connector, miniMeta
 
 // src/modules/substrate-native/module.ts
 var SubNativeBalanceModule = {
-  type: MODULE_TYPE10,
-  platform: PLATFORM10,
-  getMiniMetadata: getMiniMetadata10,
-  fetchTokens: fetchTokens10,
-  fetchBalances: fetchBalances10,
-  subscribeBalances: subscribeBalances10,
-  getTransferCallData: getTransferCallData10
+  type: MODULE_TYPE11,
+  platform: PLATFORM11,
+  getMiniMetadata: getMiniMetadata11,
+  fetchTokens: fetchTokens11,
+  fetchBalances: fetchBalances11,
+  subscribeBalances: subscribeBalances11,
+  getTransferCallData: getTransferCallData11
 };
 
 // src/modules/substrate-native/types.ts
-var import_v414 = __toESM(require("zod/v4"));
-var SubNativeTokenConfigSchema = import_v414.default.strictObject({
+var import_v416 = __toESM(require("zod/v4"));
+var SubNativeTokenConfigSchema = import_v416.default.strictObject({
   ...TokenConfigBaseSchema.shape
 });
-var SubNativeModuleConfigSchema = import_v414.default.strictObject({
-  disable: import_v414.default.boolean().optional()
+var SubNativeModuleConfigSchema = import_v416.default.strictObject({
+  disable: import_v416.default.boolean().optional()
 });
-var SubNativeMiniMetadataExtraSchema = import_v414.default.strictObject({
-  disable: import_v414.default.boolean().optional(),
-  useLegacyTransferableCalculation: import_v414.default.boolean().optional(),
-  existentialDeposit: import_v414.default.string().optional(),
-  nominationPoolsPalletId: import_v414.default.string().optional()
+var SubNativeMiniMetadataExtraSchema = import_v416.default.strictObject({
+  disable: import_v416.default.boolean().optional(),
+  useLegacyTransferableCalculation: import_v416.default.boolean().optional(),
+  existentialDeposit: import_v416.default.string().optional(),
+  nominationPoolsPalletId: import_v416.default.string().optional()
 });
 
 // src/modules/substrate-psp22/config.ts
-var import_chaindata_provider54 = require("@talismn/chaindata-provider");
-var MODULE_TYPE11 = import_chaindata_provider54.SubPsp22TokenSchema.shape.type.value;
-var PLATFORM11 = import_chaindata_provider54.SubPsp22TokenSchema.shape.platform.value;
+var import_chaindata_provider61 = require("@talismn/chaindata-provider");
+var MODULE_TYPE12 = import_chaindata_provider61.SubPsp22TokenSchema.shape.type.value;
+var PLATFORM12 = import_chaindata_provider61.SubPsp22TokenSchema.shape.platform.value;
 
 // src/modules/substrate-psp22/fetchBalances.ts
 var import_api_contract = require("@polkadot/api-contract");
@@ -6662,7 +7163,17 @@ var psp22_default = {
 };
 
 // src/modules/substrate-psp22/util.ts
-var import_util9 = require("@polkadot/util");
+var u8aToHex = (value) => `0x${Array.from(value, (b) => b.toString(16).padStart(2, "0")).join("")}`;
+var u8aConcatStrict = (arrays) => {
+  const length = arrays.reduce((total, arr) => total + arr.length, 0);
+  const result = new Uint8Array(length);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+};
 var makeContractCaller = ({
   chainConnector,
   chainId,
@@ -6671,8 +7182,8 @@ var makeContractCaller = ({
   "ContractExecResult",
   await chainConnector.send(chainId, "state_call", [
     "ContractsApi_call",
-    (0, import_util9.u8aToHex)(
-      (0, import_util9.u8aConcatStrict)([
+    u8aToHex(
+      u8aConcatStrict([
         // origin
         registry.createType("AccountId", callFrom).toU8a(),
         // dest
@@ -6691,7 +7202,7 @@ var makeContractCaller = ({
 );
 
 // src/modules/substrate-psp22/fetchBalances.ts
-var fetchBalances11 = async ({
+var fetchBalances12 = async ({
   networkId,
   tokensWithAddresses,
   connector
@@ -6746,10 +7257,11 @@ var fetchBalances11 = async ({
 // src/modules/substrate-psp22/fetchTokens.ts
 var import_api_contract2 = require("@polkadot/api-contract");
 var import_types17 = require("@polkadot/types");
-var import_util11 = require("@polkadot/util");
-var import_chaindata_provider55 = require("@talismn/chaindata-provider");
-var import_lodash_es24 = require("lodash-es");
-var fetchTokens11 = async ({
+var import_chaindata_provider62 = require("@talismn/chaindata-provider");
+var import_lodash_es27 = require("lodash-es");
+var hexToNumber = (hex) => Number(hex);
+var u8aToString = (value) => new TextDecoder().decode(value);
+var fetchTokens12 = async ({
   networkId,
   tokens,
   connector
@@ -6783,7 +7295,7 @@ var fetchTokens11 = async ({
           )
         ]);
         const symbolData = symbolResult.toJSON()?.result?.ok?.data;
-        symbol = typeof symbolData === "string" && symbolData.startsWith("0x") ? (0, import_util11.u8aToString)(
+        symbol = typeof symbolData === "string" && symbolData.startsWith("0x") ? u8aToString(
           registry.createType(
             "Option<Vec<u8>>",
             // biome-ignore lint/suspicious/noExplicitAny: legacy
@@ -6791,9 +7303,9 @@ var fetchTokens11 = async ({
           )?.value
         )?.replace(/\p{C}/gu, "") : symbol;
         const decimalsData = decimalsResult.toJSON()?.result?.ok?.data;
-        decimals = typeof decimalsData === "string" && decimalsData.startsWith("0x") ? (0, import_util11.hexToNumber)(decimalsData) : decimals;
+        decimals = typeof decimalsData === "string" && decimalsData.startsWith("0x") ? hexToNumber(decimalsData) : decimals;
       })();
-      const id = (0, import_chaindata_provider55.subPsp22TokenId)(networkId, contractAddress);
+      const id = (0, import_chaindata_provider62.subPsp22TokenId)(networkId, contractAddress);
       const token = {
         id,
         type: "substrate-psp22",
@@ -6816,21 +7328,21 @@ var fetchTokens11 = async ({
       );
     }
   }
-  return (0, import_lodash_es24.values)(tokenList).filter((t) => {
-    const parsed = import_chaindata_provider55.SubPsp22TokenSchema.safeParse(t);
+  return (0, import_lodash_es27.values)(tokenList).filter((t) => {
+    const parsed = import_chaindata_provider62.SubPsp22TokenSchema.safeParse(t);
     return parsed.success;
   });
 };
 
 // src/modules/substrate-psp22/getMiniMetadata.ts
-var import_chaindata_provider56 = require("@talismn/chaindata-provider");
+var import_chaindata_provider63 = require("@talismn/chaindata-provider");
 var import_scale24 = require("@talismn/scale");
-var getMiniMetadata11 = ({
+var getMiniMetadata12 = ({
   networkId,
   specVersion,
   metadataRpc
 }) => {
-  const source = MODULE_TYPE11;
+  const source = MODULE_TYPE12;
   const chainId = networkId;
   const systemVersion = getConstantValue(metadataRpc, "System", "Version");
   if (specVersion !== systemVersion.spec_version)
@@ -6848,7 +7360,7 @@ var getMiniMetadata11 = ({
     source,
     chainId,
     specVersion,
-    version: import_chaindata_provider56.MINIMETADATA_VERSION,
+    version: import_chaindata_provider63.MINIMETADATA_VERSION,
     data: null,
     extra: null
   };
@@ -6858,13 +7370,13 @@ var getMiniMetadata11 = ({
 var import_api_contract3 = require("@polkadot/api-contract");
 var import_types19 = require("@polkadot/types");
 var import_utils9 = require("@polkadot-api/utils");
-var import_chaindata_provider57 = require("@talismn/chaindata-provider");
+var import_chaindata_provider64 = require("@talismn/chaindata-provider");
 var import_scale25 = require("@talismn/scale");
 var import_polkadot_api7 = require("polkadot-api");
-var getTransferCallData11 = async ({ from: from2, to, value, token, metadataRpc, connector }) => {
-  if (!(0, import_chaindata_provider57.isTokenOfType)(token, MODULE_TYPE11))
-    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE11}.`);
-  const networkId = (0, import_chaindata_provider57.parseTokenId)(token.id).networkId;
+var getTransferCallData12 = async ({ from: from2, to, value, token, metadataRpc, connector }) => {
+  if (!(0, import_chaindata_provider64.isTokenOfType)(token, MODULE_TYPE12))
+    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE12}.`);
+  const networkId = (0, import_chaindata_provider64.parseTokenId)(token.id).networkId;
   const { builder } = (0, import_scale25.parseMetadataRpc)(metadataRpc);
   const { codec, location } = builder.buildCall("Contracts", "call");
   const Psp22Abi = new import_api_contract3.Abi(psp22_default);
@@ -6895,22 +7407,22 @@ var getTransferCallData11 = async ({ from: from2, to, value, token, metadataRpc,
 };
 
 // src/modules/substrate-psp22/subscribeBalances.ts
-var import_lodash_es25 = require("lodash-es");
-var import_rxjs13 = require("rxjs");
-var SUBSCRIPTION_INTERVAL8 = 6e3;
-var subscribeBalances11 = ({
+var import_lodash_es28 = require("lodash-es");
+var import_rxjs14 = require("rxjs");
+var SUBSCRIPTION_INTERVAL9 = 6e3;
+var subscribeBalances12 = ({
   networkId,
   tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
-  if (!tokensWithAddresses.length) return (0, import_rxjs13.of)({ success: [], errors: [] });
-  return new import_rxjs13.Observable((subscriber) => {
+  if (!tokensWithAddresses.length) return (0, import_rxjs14.of)({ success: [], errors: [] });
+  return new import_rxjs14.Observable((subscriber) => {
     const abortController = new AbortController();
     const poll = async () => {
       try {
         if (abortController.signal.aborted) return;
-        const balances = await fetchBalances11({
+        const balances = await fetchBalances12({
           networkId,
           tokensWithAddresses,
           connector,
@@ -6918,10 +7430,10 @@ var subscribeBalances11 = ({
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL8);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL9);
       } catch (error) {
         log_default.error("Error", {
-          module: MODULE_TYPE11,
+          module: MODULE_TYPE12,
           networkId,
           miniMetadata,
           addressesByToken: tokensWithAddresses,
@@ -6934,36 +7446,36 @@ var subscribeBalances11 = ({
     return () => {
       abortController.abort();
     };
-  }).pipe((0, import_rxjs13.distinctUntilChanged)(import_lodash_es25.isEqual));
+  }).pipe((0, import_rxjs14.distinctUntilChanged)(import_lodash_es28.isEqual));
 };
 
 // src/modules/substrate-psp22/module.ts
 var SubPsp22BalanceModule = {
-  type: MODULE_TYPE11,
-  platform: PLATFORM11,
-  getMiniMetadata: getMiniMetadata11,
-  fetchTokens: fetchTokens11,
-  fetchBalances: fetchBalances11,
-  subscribeBalances: subscribeBalances11,
-  getTransferCallData: getTransferCallData11
+  type: MODULE_TYPE12,
+  platform: PLATFORM12,
+  getMiniMetadata: getMiniMetadata12,
+  fetchTokens: fetchTokens12,
+  fetchBalances: fetchBalances12,
+  subscribeBalances: subscribeBalances12,
+  getTransferCallData: getTransferCallData12
 };
 
 // src/modules/substrate-psp22/types.ts
-var import_chaindata_provider58 = require("@talismn/chaindata-provider");
-var import_v415 = __toESM(require("zod/v4"));
-var SubPsp22TokenConfigSchema = import_v415.default.strictObject({
-  contractAddress: import_chaindata_provider58.SubPsp22TokenSchema.shape.contractAddress,
+var import_chaindata_provider65 = require("@talismn/chaindata-provider");
+var import_v417 = __toESM(require("zod/v4"));
+var SubPsp22TokenConfigSchema = import_v417.default.strictObject({
+  contractAddress: import_chaindata_provider65.SubPsp22TokenSchema.shape.contractAddress,
   ...TokenConfigBaseSchema.shape
 });
 
 // src/modules/substrate-tokens/config.ts
-var import_chaindata_provider59 = require("@talismn/chaindata-provider");
-var MODULE_TYPE12 = import_chaindata_provider59.SubTokensTokenSchema.shape.type.value;
-var PLATFORM12 = import_chaindata_provider59.SubTokensTokenSchema.shape.platform.value;
+var import_chaindata_provider66 = require("@talismn/chaindata-provider");
+var MODULE_TYPE13 = import_chaindata_provider66.SubTokensTokenSchema.shape.type.value;
+var PLATFORM13 = import_chaindata_provider66.SubTokensTokenSchema.shape.platform.value;
 
 // src/modules/substrate-tokens/buildQueries.ts
 var import_scale26 = require("@talismn/scale");
-var import_util14 = require("@talismn/util");
+var import_util13 = require("@talismn/util");
 var buildQueries3 = (networkId, balanceDefs, miniMetadata) => {
   const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
     storage: [miniMetadata.extra.palletId, "Accounts"]
@@ -7011,15 +7523,15 @@ var buildQueries3 = (networkId, balanceDefs, miniMetadata) => {
       stateKeys: [stateKey],
       decodeResult
     };
-  }).filter(import_util14.isNotNil);
+  }).filter(import_util13.isNotNil);
 };
 
 // src/modules/substrate-tokens/fetchBalances.ts
-var fetchBalances12 = async ({ networkId, tokensWithAddresses, connector, miniMetadata }) => {
+var fetchBalances13 = async ({ networkId, tokensWithAddresses, connector, miniMetadata }) => {
   if (!tokensWithAddresses.length) return { success: [], errors: [] };
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!miniMetadata?.data) {
-    log_default.warn(`MiniMetadata is required for fetching ${MODULE_TYPE12} balances on ${networkId}.`);
+    log_default.warn(`MiniMetadata is required for fetching ${MODULE_TYPE13} balances on ${networkId}.`);
     return {
       success: [],
       errors: balanceDefs.map((def) => ({
@@ -7029,20 +7541,20 @@ var fetchBalances12 = async ({ networkId, tokensWithAddresses, connector, miniMe
       }))
     };
   }
-  if (miniMetadata.source !== MODULE_TYPE12) {
-    log_default.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE12}.`);
+  if (miniMetadata.source !== MODULE_TYPE13) {
+    log_default.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE13}.`);
     return {
       success: [],
       errors: balanceDefs.map((def) => ({
         tokenId: def.token.id,
         address: def.address,
-        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE12}`)
+        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE13}`)
       }))
     };
   }
   if (miniMetadata.chainId !== networkId) {
     log_default.warn(
-      `Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE12}. Expected chainId is ${networkId}`
+      `Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE13}. Expected chainId is ${networkId}`
     );
     return {
       success: [],
@@ -7066,7 +7578,7 @@ var fetchBalances12 = async ({ networkId, tokensWithAddresses, connector, miniMe
           address: def.address,
           networkId,
           tokenId: def.token.id,
-          source: MODULE_TYPE12,
+          source: MODULE_TYPE13,
           status: "live",
           values: [
             { type: "free", label: "free", amount: "0" },
@@ -7080,20 +7592,20 @@ var fetchBalances12 = async ({ networkId, tokensWithAddresses, connector, miniMe
 };
 
 // src/modules/substrate-tokens/fetchTokens.ts
-var import_chaindata_provider60 = require("@talismn/chaindata-provider");
-var import_lodash_es26 = require("lodash-es");
-var fetchTokens12 = async ({
+var import_chaindata_provider67 = require("@talismn/chaindata-provider");
+var import_lodash_es29 = require("lodash-es");
+var fetchTokens13 = async ({
   networkId,
   tokens,
   miniMetadata
 }) => {
   if (!miniMetadata?.data) return [];
   return tokens.map(
-    (tokenConfig) => (0, import_lodash_es26.assign)(
+    (tokenConfig) => (0, import_lodash_es29.assign)(
       {
-        id: (0, import_chaindata_provider60.subTokensTokenId)(networkId, tokenConfig.onChainId),
-        type: MODULE_TYPE12,
-        platform: PLATFORM12,
+        id: (0, import_chaindata_provider67.subTokensTokenId)(networkId, tokenConfig.onChainId),
+        type: MODULE_TYPE13,
+        platform: PLATFORM13,
         networkId,
         onChainId: tokenConfig.onChainId,
         symbol: tokenConfig.symbol ?? "Unit",
@@ -7108,10 +7620,10 @@ var fetchTokens12 = async ({
 };
 
 // src/modules/substrate-tokens/getMiniMetadata.ts
-var import_chaindata_provider61 = require("@talismn/chaindata-provider");
+var import_chaindata_provider68 = require("@talismn/chaindata-provider");
 var import_scale27 = require("@talismn/scale");
-var getMiniMetadata12 = ({ networkId, specVersion, metadataRpc, config }) => {
-  const source = MODULE_TYPE12;
+var getMiniMetadata13 = ({ networkId, specVersion, metadataRpc, config }) => {
+  const source = MODULE_TYPE13;
   const chainId = networkId;
   const systemVersion = getConstantValue(metadataRpc, "System", "Version");
   if (specVersion !== systemVersion.spec_version)
@@ -7130,7 +7642,7 @@ var getMiniMetadata12 = ({ networkId, specVersion, metadataRpc, config }) => {
     source,
     chainId,
     specVersion,
-    version: import_chaindata_provider61.MINIMETADATA_VERSION,
+    version: import_chaindata_provider68.MINIMETADATA_VERSION,
     data: getData5(metadataRpc, extra.palletId),
     extra
   };
@@ -7144,12 +7656,12 @@ var getData5 = (metadataRpc, pallet) => {
 
 // src/modules/substrate-tokens/getTransferCallData.ts
 var import_utils10 = require("@polkadot-api/utils");
-var import_chaindata_provider62 = require("@talismn/chaindata-provider");
+var import_chaindata_provider69 = require("@talismn/chaindata-provider");
 var import_scale28 = require("@talismn/scale");
 var import_polkadot_api8 = require("polkadot-api");
-var getTransferCallData12 = ({ from: from2, to, value, token, type, metadataRpc, config }) => {
-  if (!(0, import_chaindata_provider62.isTokenOfType)(token, MODULE_TYPE12))
-    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE12}.`);
+var getTransferCallData13 = ({ from: from2, to, value, token, type, metadataRpc, config }) => {
+  if (!(0, import_chaindata_provider69.isTokenOfType)(token, MODULE_TYPE13))
+    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE13}.`);
   const { builder } = (0, import_scale28.parseMetadataRpc)(metadataRpc);
   const options = getCallDataOptions(to, token, value, type, config);
   const callData = getCallDataFromOptions(builder, options);
@@ -7262,13 +7774,13 @@ var getCallDataOptions = (to, token, value, type, config) => {
 };
 
 // src/modules/substrate-tokens/subscribeBalances.ts
-var import_rxjs14 = require("rxjs");
-var subscribeBalances12 = ({ networkId, tokensWithAddresses, connector, miniMetadata }) => {
-  if (!tokensWithAddresses.length) return (0, import_rxjs14.of)({ success: [], errors: [] });
+var import_rxjs15 = require("rxjs");
+var subscribeBalances13 = ({ networkId, tokensWithAddresses, connector, miniMetadata }) => {
+  if (!tokensWithAddresses.length) return (0, import_rxjs15.of)({ success: [], errors: [] });
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   const queries = buildQueries3(networkId, balanceDefs, miniMetadata);
   return getRpcQueryPack$(connector, networkId, queries).pipe(
-    (0, import_rxjs14.map)((balances) => ({
+    (0, import_rxjs15.map)((balances) => ({
       success: balances,
       errors: []
     }))
@@ -7277,31 +7789,31 @@ var subscribeBalances12 = ({ networkId, tokensWithAddresses, connector, miniMeta
 
 // src/modules/substrate-tokens/module.ts
 var SubTokensBalanceModule = {
-  type: MODULE_TYPE12,
-  platform: PLATFORM12,
-  getMiniMetadata: getMiniMetadata12,
-  fetchTokens: fetchTokens12,
-  fetchBalances: fetchBalances12,
-  subscribeBalances: subscribeBalances12,
-  getTransferCallData: getTransferCallData12
+  type: MODULE_TYPE13,
+  platform: PLATFORM13,
+  getMiniMetadata: getMiniMetadata13,
+  fetchTokens: fetchTokens13,
+  fetchBalances: fetchBalances13,
+  subscribeBalances: subscribeBalances13,
+  getTransferCallData: getTransferCallData13
 };
 
 // src/modules/substrate-tokens/types.ts
-var import_chaindata_provider63 = require("@talismn/chaindata-provider");
-var import_v416 = __toESM(require("zod/v4"));
-var SubTokensTokenConfigSchema = import_v416.default.strictObject({
-  onChainId: import_chaindata_provider63.SubTokensTokenSchema.shape.onChainId,
+var import_chaindata_provider70 = require("@talismn/chaindata-provider");
+var import_v418 = __toESM(require("zod/v4"));
+var SubTokensTokenConfigSchema = import_v418.default.strictObject({
+  onChainId: import_chaindata_provider70.SubTokensTokenSchema.shape.onChainId,
   ...TokenConfigBaseSchema.shape,
   // force these 3 fields because in this module we wont pull anything from chain
-  symbol: import_v416.default.string().nonempty(),
-  decimals: import_v416.default.number(),
-  existentialDeposit: import_v416.default.string().nonempty()
+  symbol: import_v418.default.string().nonempty(),
+  decimals: import_v418.default.number(),
+  existentialDeposit: import_v418.default.string().nonempty()
 });
-var SubTokensModuleConfigSchema = import_v416.default.strictObject({
-  palletId: import_v416.default.string().optional()
+var SubTokensModuleConfigSchema = import_v418.default.strictObject({
+  palletId: import_v418.default.string().optional()
 });
-var SubTokensMiniMetadataExtraSchema = import_v416.default.strictObject({
-  palletId: import_v416.default.string()
+var SubTokensMiniMetadataExtraSchema = import_v418.default.strictObject({
+  palletId: import_v418.default.string()
 });
 
 // src/modules/index.ts
@@ -7317,12 +7829,13 @@ var BALANCE_MODULES = [
   EvmUniswapV2BalanceModule,
   EvmNativeBalanceModule,
   SolNativeBalanceModule,
-  SolSplBalanceModule
+  SolSplBalanceModule,
+  SolToken2022BalanceModule
 ];
 
 // src/getMiniMetadatas/getMetadataRpc.ts
 var import_sapi = require("@talismn/sapi");
-var import_util15 = require("@talismn/util");
+var import_util14 = require("@talismn/util");
 var CACHE = /* @__PURE__ */ new Map();
 var getMetadataRpc = async (chainConnector, networkId) => {
   if (CACHE.has(networkId)) return CACHE.get(networkId);
@@ -7336,7 +7849,7 @@ var getMetadataRpc = async (chainConnector, networkId) => {
   try {
     return await pResult;
   } catch (cause) {
-    if ((0, import_util15.isAbortError)(cause)) throw cause;
+    if ((0, import_util14.isAbortError)(cause)) throw cause;
     throw new Error(`Failed to fetch metadataRpc for network ${networkId}`, { cause });
   } finally {
     CACHE.delete(networkId);
@@ -7424,37 +7937,37 @@ var BalancesProvider = class {
   constructor(chaindataProvider, chainConnectors, storage = DEFAULT_STORAGE) {
     this.#chaindataProvider = chaindataProvider;
     this.#chainConnectors = chainConnectors;
-    this.#storage = new import_rxjs15.BehaviorSubject({
-      balances: (0, import_lodash_es27.keyBy)(storage.balances.filter(import_util16.isNotNil), (b) => getBalanceId(b)),
-      miniMetadatas: (0, import_lodash_es27.keyBy)(storage.miniMetadatas.filter(import_util16.isNotNil), (m) => m.id)
+    this.#storage = new import_rxjs16.BehaviorSubject({
+      balances: (0, import_lodash_es30.keyBy)(storage.balances.filter(import_util15.isNotNil), (b) => getBalanceId(b)),
+      miniMetadatas: (0, import_lodash_es30.keyBy)(storage.miniMetadatas.filter(import_util15.isNotNil), (m) => m.id)
     });
   }
   get storage$() {
     return this.#storage.pipe(
-      (0, import_rxjs15.map)(
+      (0, import_rxjs16.map)(
         ({ balances, miniMetadatas }) => ({
-          balances: (0, import_lodash_es27.values)(balances).filter(import_util16.isNotNil).sort(sortByBalanceId),
-          miniMetadatas: (0, import_lodash_es27.values)(miniMetadatas).filter(import_util16.isNotNil).sort(sortByMiniMetadataId)
+          balances: (0, import_lodash_es30.values)(balances).filter(import_util15.isNotNil).sort(sortByBalanceId),
+          miniMetadatas: (0, import_lodash_es30.values)(miniMetadatas).filter(import_util15.isNotNil).sort(sortByMiniMetadataId)
         }),
-        (0, import_rxjs15.shareReplay)(1)
+        (0, import_rxjs16.shareReplay)(1)
       )
     );
   }
   get storedMiniMetadataMapById$() {
     return this.#storage.pipe(
-      (0, import_rxjs15.map)((storage) => (0, import_lodash_es27.keyBy)(storage.miniMetadatas, (m) => m.id)),
-      (0, import_rxjs15.distinctUntilChanged)(import_lodash_es27.isEqual),
-      (0, import_rxjs15.shareReplay)(1)
+      (0, import_rxjs16.map)((storage) => (0, import_lodash_es30.keyBy)(storage.miniMetadatas, (m) => m.id)),
+      (0, import_rxjs16.distinctUntilChanged)(import_lodash_es30.isEqual),
+      (0, import_rxjs16.shareReplay)(1)
     );
   }
   // this is the only public method
   getBalances$(addressesByTokenId) {
     return this.cleanupAddressesByTokenId$(addressesByTokenId).pipe(
-      (0, import_rxjs15.map)(
+      (0, import_rxjs16.map)(
         // split by network
-        (addressesByTokenId2) => (0, import_lodash_es27.toPairs)(addressesByTokenId2).reduce(
+        (addressesByTokenId2) => (0, import_lodash_es30.toPairs)(addressesByTokenId2).reduce(
           (acc, [tokenId, addresses]) => {
-            const networkId = (0, import_chaindata_provider64.parseTokenId)(tokenId).networkId;
+            const networkId = (0, import_chaindata_provider71.parseTokenId)(tokenId).networkId;
             if (!acc[networkId]) acc[networkId] = {};
             acc[networkId][tokenId] = addresses;
             return acc;
@@ -7462,21 +7975,21 @@ var BalancesProvider = class {
           {}
         )
       ),
-      (0, import_rxjs15.switchMap)((addressesByTokenIdByNetworkId) => {
-        if (!(0, import_lodash_es27.keys)(addressesByTokenIdByNetworkId).length) return (0, import_rxjs15.of)({ isStale: false, results: [] });
-        return (0, import_rxjs15.combineLatest)({
-          isStale: (0, import_rxjs15.timer)(3e4).pipe(
-            (0, import_rxjs15.map)(() => true),
-            (0, import_rxjs15.startWith)(false)
+      (0, import_rxjs16.switchMap)((addressesByTokenIdByNetworkId) => {
+        if (!(0, import_lodash_es30.keys)(addressesByTokenIdByNetworkId).length) return (0, import_rxjs16.of)({ isStale: false, results: [] });
+        return (0, import_rxjs16.combineLatest)({
+          isStale: (0, import_rxjs16.timer)(3e4).pipe(
+            (0, import_rxjs16.map)(() => true),
+            (0, import_rxjs16.startWith)(false)
           ),
-          results: (0, import_rxjs15.combineLatest)(
-            (0, import_lodash_es27.toPairs)(addressesByTokenIdByNetworkId).map(
+          results: (0, import_rxjs16.combineLatest)(
+            (0, import_lodash_es30.toPairs)(addressesByTokenIdByNetworkId).map(
               ([networkId]) => this.getNetworkBalances$(networkId, addressesByTokenIdByNetworkId[networkId])
             )
           )
         });
       }),
-      (0, import_rxjs15.map)(
+      (0, import_rxjs16.map)(
         // combine
         ({ isStale, results }) => ({
           status: !isStale && results.some(({ status }) => status === "initialising") ? "initialising" : "live",
@@ -7488,14 +8001,14 @@ var BalancesProvider = class {
           failedBalanceIds: results.flatMap((result) => result.failedBalanceIds)
         })
       ),
-      (0, import_rxjs15.distinctUntilChanged)(import_lodash_es27.isEqual)
+      (0, import_rxjs16.distinctUntilChanged)(import_lodash_es30.isEqual)
     );
   }
   fetchBalances(addressesByTokenId) {
-    return (0, import_rxjs15.firstValueFrom)(
+    return (0, import_rxjs16.firstValueFrom)(
       this.getBalances$(addressesByTokenId).pipe(
-        (0, import_rxjs15.filter)(({ status }) => status === "live"),
-        (0, import_rxjs15.map)(({ balances }) => balances)
+        (0, import_rxjs16.filter)(({ status }) => status === "live"),
+        (0, import_rxjs16.map)(({ balances }) => balances)
       )
     );
   }
@@ -7505,12 +8018,12 @@ var BalancesProvider = class {
   getNetworkBalances$(networkId, addressesByTokenId) {
     const network$ = this.#chaindataProvider.getNetworkById$(networkId);
     const tokensMapById$ = this.#chaindataProvider.getTokensMapById$();
-    return (0, import_rxjs15.combineLatest)([network$, tokensMapById$]).pipe(
-      (0, import_rxjs15.switchMap)(([network, tokensMapById]) => {
-        const tokensAndAddresses = (0, import_lodash_es27.toPairs)(addressesByTokenId).map(
+    return (0, import_rxjs16.combineLatest)([network$, tokensMapById$]).pipe(
+      (0, import_rxjs16.switchMap)(([network, tokensMapById]) => {
+        const tokensAndAddresses = (0, import_lodash_es30.toPairs)(addressesByTokenId).map(
           ([tokenId, addresses]) => [tokensMapById[tokenId], addresses]
         );
-        return (0, import_rxjs15.combineLatest)(
+        return (0, import_rxjs16.combineLatest)(
           BALANCE_MODULES.filter((mod) => mod.platform === network?.platform).map((mod) => {
             const tokensWithAddresses = tokensAndAddresses.filter(
               ([token]) => token.type === mod.type
@@ -7527,41 +8040,41 @@ var BalancesProvider = class {
               }
               default: {
                 log_default.warn("[balances] Unsupported network platform for module", { networkId, mod });
-                return (0, import_rxjs15.of)({ status: "live", balances: [], failedBalanceIds: [] });
+                return (0, import_rxjs16.of)({ status: "live", balances: [], failedBalanceIds: [] });
               }
             }
           })
         );
       }),
-      (0, import_rxjs15.map)((results) => {
+      (0, import_rxjs16.map)((results) => {
         const errorBalanceIds = results.flatMap((result) => result.failedBalanceIds);
-        const staleBalances = errorBalanceIds.map((balanceId) => this.#storage.value.balances[balanceId]).filter(import_util16.isNotNil).map((b) => ({ ...b, status: "stale" }));
+        const staleBalances = errorBalanceIds.map((balanceId) => this.#storage.value.balances[balanceId]).filter(import_util15.isNotNil).map((b) => ({ ...b, status: "stale" }));
         return {
           status: results.some(({ status }) => status === "initialising") ? "initialising" : "live",
           balances: results.flatMap((result) => result.balances).concat(staleBalances).sort(sortByBalanceId),
           failedBalanceIds: []
         };
       }),
-      (0, import_rxjs15.distinctUntilChanged)(import_lodash_es27.isEqual)
+      (0, import_rxjs16.distinctUntilChanged)(import_lodash_es30.isEqual)
     );
   }
   getPolkadotNetworkModuleBalances$(networkId, tokensWithAddresses, mod) {
-    return (0, import_util16.getSharedObservable)(
+    return (0, import_util15.getSharedObservable)(
       `BalancesProvider.getPolkadotNetworkModuleBalances$`,
       { networkId, mod, tokensWithAddresses },
       () => {
         if (!tokensWithAddresses.length)
-          return (0, import_rxjs15.of)({ status: "live", balances: [], failedBalanceIds: [] });
-        const moduleAddressesByTokenId = (0, import_lodash_es27.fromPairs)(
+          return (0, import_rxjs16.of)({ status: "live", balances: [], failedBalanceIds: [] });
+        const moduleAddressesByTokenId = (0, import_lodash_es30.fromPairs)(
           tokensWithAddresses.map(([token, addresses]) => [token.id, addresses])
         );
-        const balanceIds = (0, import_lodash_es27.toPairs)(moduleAddressesByTokenId).flatMap(
+        const balanceIds = (0, import_lodash_es30.toPairs)(moduleAddressesByTokenId).flatMap(
           ([tokenId, addresses]) => addresses.map((address) => getBalanceId({ tokenId, address }))
         );
         if (!this.#chainConnectors.substrate) {
           log_default.warn("[balances] no substrate connector or miniMetadata for module", mod.type);
-          return (0, import_rxjs15.defer)(
-            () => (0, import_rxjs15.of)({
+          return (0, import_rxjs16.defer)(
+            () => (0, import_rxjs16.of)({
               status: "initialising",
               balances: this.getStoredBalances(moduleAddressesByTokenId),
               failedBalanceIds: []
@@ -7569,8 +8082,8 @@ var BalancesProvider = class {
           );
         }
         const moduleBalances$ = this.getNetworkMiniMetadatas$(networkId).pipe(
-          (0, import_rxjs15.map)((miniMetadatas) => miniMetadatas.find((m) => m.source === mod.type)),
-          (0, import_rxjs15.switchMap)(
+          (0, import_rxjs16.map)((miniMetadatas) => miniMetadatas.find((m) => m.source === mod.type)),
+          (0, import_rxjs16.switchMap)(
             (miniMetadata) => mod.subscribeBalances({
               networkId,
               tokensWithAddresses,
@@ -7578,14 +8091,14 @@ var BalancesProvider = class {
               miniMetadata
             })
           ),
-          (0, import_rxjs15.catchError)(() => import_rxjs15.EMPTY),
+          (0, import_rxjs16.catchError)(() => import_rxjs16.EMPTY),
           // don't emit, let provider mark balances stale
-          (0, import_rxjs15.tap)((results) => {
+          (0, import_rxjs16.tap)((results) => {
             if (results.dynamicTokens?.length) {
               this.#chaindataProvider.registerDynamicTokens(results.dynamicTokens);
             }
           }),
-          (0, import_rxjs15.map)(
+          (0, import_rxjs16.map)(
             (results) => ({
               status: "live",
               // exclude zero balances
@@ -7595,16 +8108,16 @@ var BalancesProvider = class {
               )
             })
           ),
-          (0, import_rxjs15.tap)((results) => {
+          (0, import_rxjs16.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
-          (0, import_rxjs15.shareReplay)({ refCount: true, bufferSize: 1 }),
-          (0, import_util16.keepAlive)(0)
+          (0, import_rxjs16.shareReplay)({ refCount: true, bufferSize: 1 }),
+          (0, import_util15.keepAlive)(0)
         );
-        return (0, import_rxjs15.defer)(
+        return (0, import_rxjs16.defer)(
           () => moduleBalances$.pipe(
-            (0, import_rxjs15.startWith)({
+            (0, import_rxjs16.startWith)({
               status: "initialising",
               balances: this.getStoredBalances(moduleAddressesByTokenId),
               failedBalanceIds: []
@@ -7615,22 +8128,22 @@ var BalancesProvider = class {
     );
   }
   getEthereumNetworkModuleBalances$(networkId, tokensWithAddresses, mod) {
-    return (0, import_util16.getSharedObservable)(
+    return (0, import_util15.getSharedObservable)(
       `BalancesProvider.getEthereumNetworkModuleBalances$`,
       { networkId, mod, tokensWithAddresses },
       () => {
         if (!tokensWithAddresses.length)
-          return (0, import_rxjs15.of)({ status: "live", balances: [], failedBalanceIds: [] });
-        const moduleAddressesByTokenId = (0, import_lodash_es27.fromPairs)(
+          return (0, import_rxjs16.of)({ status: "live", balances: [], failedBalanceIds: [] });
+        const moduleAddressesByTokenId = (0, import_lodash_es30.fromPairs)(
           tokensWithAddresses.map(([token, addresses]) => [token.id, addresses])
         );
-        const balanceIds = (0, import_lodash_es27.toPairs)(moduleAddressesByTokenId).flatMap(
+        const balanceIds = (0, import_lodash_es30.toPairs)(moduleAddressesByTokenId).flatMap(
           ([tokenId, addresses]) => addresses.map((address) => getBalanceId({ tokenId, address }))
         );
         if (!this.#chainConnectors.evm) {
           log_default.warn("[balances] no ethereum connector for module", mod.type);
-          return (0, import_rxjs15.defer)(
-            () => (0, import_rxjs15.of)({
+          return (0, import_rxjs16.defer)(
+            () => (0, import_rxjs16.of)({
               status: "initialising",
               balances: this.getStoredBalances(moduleAddressesByTokenId),
               failedBalanceIds: []
@@ -7642,9 +8155,9 @@ var BalancesProvider = class {
           tokensWithAddresses,
           connector: this.#chainConnectors.evm
         }).pipe(
-          (0, import_rxjs15.catchError)(() => import_rxjs15.EMPTY),
+          (0, import_rxjs16.catchError)(() => import_rxjs16.EMPTY),
           // don't emit, let provider mark balances stale
-          (0, import_rxjs15.map)(
+          (0, import_rxjs16.map)(
             (results) => ({
               status: "live",
               // exclude zero balances
@@ -7654,16 +8167,16 @@ var BalancesProvider = class {
               )
             })
           ),
-          (0, import_rxjs15.tap)((results) => {
+          (0, import_rxjs16.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
-          (0, import_rxjs15.shareReplay)({ refCount: true, bufferSize: 1 }),
-          (0, import_util16.keepAlive)(0)
+          (0, import_rxjs16.shareReplay)({ refCount: true, bufferSize: 1 }),
+          (0, import_util15.keepAlive)(0)
         );
-        return (0, import_rxjs15.defer)(
+        return (0, import_rxjs16.defer)(
           () => moduleBalances$.pipe(
-            (0, import_rxjs15.startWith)({
+            (0, import_rxjs16.startWith)({
               status: "initialising",
               balances: this.getStoredBalances(moduleAddressesByTokenId),
               failedBalanceIds: []
@@ -7674,22 +8187,22 @@ var BalancesProvider = class {
     );
   }
   getSolanaNetworkModuleBalances$(networkId, tokensWithAddresses, mod) {
-    return (0, import_util16.getSharedObservable)(
+    return (0, import_util15.getSharedObservable)(
       `BalancesProvider.getSolanaNetworkModuleBalances$`,
       { networkId, mod, tokensWithAddresses },
       () => {
         if (!tokensWithAddresses.length)
-          return (0, import_rxjs15.of)({ status: "live", balances: [], failedBalanceIds: [] });
-        const moduleAddressesByTokenId = (0, import_lodash_es27.fromPairs)(
+          return (0, import_rxjs16.of)({ status: "live", balances: [], failedBalanceIds: [] });
+        const moduleAddressesByTokenId = (0, import_lodash_es30.fromPairs)(
           tokensWithAddresses.map(([token, addresses]) => [token.id, addresses])
         );
-        const balanceIds = (0, import_lodash_es27.toPairs)(moduleAddressesByTokenId).flatMap(
+        const balanceIds = (0, import_lodash_es30.toPairs)(moduleAddressesByTokenId).flatMap(
           ([tokenId, addresses]) => addresses.map((address) => getBalanceId({ tokenId, address }))
         );
         if (!this.#chainConnectors.solana) {
           log_default.warn("[balances] no solana connector for module", mod.type);
-          return (0, import_rxjs15.defer)(
-            () => (0, import_rxjs15.of)({
+          return (0, import_rxjs16.defer)(
+            () => (0, import_rxjs16.of)({
               status: "initialising",
               balances: this.getStoredBalances(moduleAddressesByTokenId),
               failedBalanceIds: []
@@ -7701,9 +8214,14 @@ var BalancesProvider = class {
           tokensWithAddresses,
           connector: this.#chainConnectors.solana
         }).pipe(
-          (0, import_rxjs15.catchError)(() => import_rxjs15.EMPTY),
+          (0, import_rxjs16.catchError)(() => import_rxjs16.EMPTY),
           // don't emit, let provider mark balances stale
-          (0, import_rxjs15.map)(
+          (0, import_rxjs16.tap)((results) => {
+            if (results.dynamicTokens?.length) {
+              this.#chaindataProvider.registerDynamicTokens(results.dynamicTokens);
+            }
+          }),
+          (0, import_rxjs16.map)(
             (results) => ({
               status: "live",
               // exclude zero balances
@@ -7713,16 +8231,16 @@ var BalancesProvider = class {
               )
             })
           ),
-          (0, import_rxjs15.tap)((results) => {
+          (0, import_rxjs16.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
-          (0, import_rxjs15.shareReplay)({ refCount: true, bufferSize: 1 }),
-          (0, import_util16.keepAlive)(0)
+          (0, import_rxjs16.shareReplay)({ refCount: true, bufferSize: 1 }),
+          (0, import_util15.keepAlive)(0)
         );
-        return (0, import_rxjs15.defer)(
+        return (0, import_rxjs16.defer)(
           () => moduleBalances$.pipe(
-            (0, import_rxjs15.startWith)({
+            (0, import_rxjs16.startWith)({
               status: "initialising",
               balances: this.getStoredBalances(moduleAddressesByTokenId),
               failedBalanceIds: []
@@ -7736,14 +8254,14 @@ var BalancesProvider = class {
     if (balancesResult.status !== "live") return;
     const storage = this.#storage.getValue();
     const failedIds = new Set(balancesResult.failedBalanceIds);
-    const balances = (0, import_lodash_es27.assign)(
+    const balances = (0, import_lodash_es30.assign)(
       {},
       storage.balances,
       // delete all balances expected in the result set (except the ones that failed). because if they are not present it means they are empty.
-      (0, import_lodash_es27.fromPairs)(
+      (0, import_lodash_es30.fromPairs)(
         balanceIds.filter((bid) => !failedIds.has(bid)).map((balanceId) => [balanceId, void 0])
       ),
-      (0, import_lodash_es27.keyBy)(
+      (0, import_lodash_es30.keyBy)(
         // storage balances must have status "cache", because they are used as start value when initialising subsequent subscriptions
         balancesResult.balances.map((b) => ({ ...b, status: "cache" })),
         (b) => getBalanceId(b)
@@ -7753,24 +8271,24 @@ var BalancesProvider = class {
       const balance = balances[errorBalanceId];
       if (balance) balance.status = "stale";
     }
-    this.#storage.next((0, import_lodash_es27.assign)({}, storage, { balances }));
+    this.#storage.next((0, import_lodash_es30.assign)({}, storage, { balances }));
   }
   getNetworkMiniMetadatas$(networkId) {
-    return (0, import_util16.getSharedObservable)(`BalancesProvider.getNetworkMiniMetadatas$`, { networkId }, () => {
+    return (0, import_util15.getSharedObservable)(`BalancesProvider.getNetworkMiniMetadatas$`, { networkId }, () => {
       return this.#chaindataProvider.getNetworkById$(networkId).pipe(
-        (0, import_rxjs15.switchMap)(
-          (network) => (0, import_chaindata_provider64.isNetworkDot)(network) ? this.getNetworkSpecVersion$(networkId).pipe(
-            (0, import_rxjs15.switchMap)(
-              (specVersion) => specVersion === null ? (0, import_rxjs15.of)([]) : this.getMiniMetadatas$(networkId, specVersion)
+        (0, import_rxjs16.switchMap)(
+          (network) => (0, import_chaindata_provider71.isNetworkDot)(network) ? this.getNetworkSpecVersion$(networkId).pipe(
+            (0, import_rxjs16.switchMap)(
+              (specVersion) => specVersion === null ? (0, import_rxjs16.of)([]) : this.getMiniMetadatas$(networkId, specVersion)
             )
-          ) : (0, import_rxjs15.of)([])
+          ) : (0, import_rxjs16.of)([])
         ),
-        (0, import_rxjs15.distinctUntilChanged)(import_lodash_es27.isEqual)
+        (0, import_rxjs16.distinctUntilChanged)(import_lodash_es30.isEqual)
       );
     });
   }
   getNetworkSpecVersion$(networkId) {
-    return (0, import_rxjs15.from)(
+    return (0, import_rxjs16.from)(
       (0, import_viem9.withRetry)(() => getSpecVersion(this.#chainConnectors.substrate, networkId), {
         delay: 2e3,
         shouldRetry: (err) => {
@@ -7779,9 +8297,9 @@ var BalancesProvider = class {
         }
       })
     ).pipe(
-      (0, import_rxjs15.catchError)(() => {
+      (0, import_rxjs16.catchError)(() => {
         log_default.warn("Failed to fetch spec version for network", networkId);
-        return (0, import_rxjs15.of)(null);
+        return (0, import_rxjs16.of)(null);
       })
     );
   }
@@ -7793,15 +8311,15 @@ var BalancesProvider = class {
         source: mod.type
       })
     );
-    return (0, import_rxjs15.combineLatest)({
+    return (0, import_rxjs16.combineLatest)({
       defaultMiniMetadatas: this.getDefaultMiniMetadatas$(miniMetadataIds),
       storedMiniMetadatas: this.getStoredMiniMetadatas$(miniMetadataIds)
     }).pipe(
-      (0, import_rxjs15.switchMap)(({ storedMiniMetadatas, defaultMiniMetadatas }) => {
-        if (defaultMiniMetadatas) return (0, import_rxjs15.of)(defaultMiniMetadatas);
-        if (storedMiniMetadatas) return (0, import_rxjs15.of)(storedMiniMetadatas);
-        if (!this.#chainConnectors.substrate) return (0, import_rxjs15.of)([]);
-        return (0, import_rxjs15.from)(
+      (0, import_rxjs16.switchMap)(({ storedMiniMetadatas, defaultMiniMetadatas }) => {
+        if (defaultMiniMetadatas) return (0, import_rxjs16.of)(defaultMiniMetadatas);
+        if (storedMiniMetadatas) return (0, import_rxjs16.of)(storedMiniMetadatas);
+        if (!this.#chainConnectors.substrate) return (0, import_rxjs16.of)([]);
+        return (0, import_rxjs16.from)(
           (0, import_viem9.withRetry)(
             () => (
               // can fail if metadata cant be fetched
@@ -7821,65 +8339,65 @@ var BalancesProvider = class {
             }
           )
         ).pipe(
-          (0, import_rxjs15.catchError)(() => {
+          (0, import_rxjs16.catchError)(() => {
             log_default.warn("Failed to fetch metadata for network", networkId);
-            return (0, import_rxjs15.of)([]);
+            return (0, import_rxjs16.of)([]);
           }),
           // and persist in storage for later reuse
-          (0, import_rxjs15.tap)((newMiniMetadatas) => {
+          (0, import_rxjs16.tap)((newMiniMetadatas) => {
             if (!newMiniMetadatas.length) return;
             const storage = this.#storage.getValue();
-            const miniMetadatas = (0, import_lodash_es27.assign)(
+            const miniMetadatas = (0, import_lodash_es30.assign)(
               // keep minimetadatas of other networks
-              (0, import_lodash_es27.keyBy)(
-                (0, import_lodash_es27.values)(storage.miniMetadatas).filter((m) => m.chainId !== networkId),
+              (0, import_lodash_es30.keyBy)(
+                (0, import_lodash_es30.values)(storage.miniMetadatas).filter((m) => m.chainId !== networkId),
                 (m) => m.id
               ),
               // add the ones for our network
-              (0, import_lodash_es27.keyBy)(newMiniMetadatas, (m) => m.id)
+              (0, import_lodash_es30.keyBy)(newMiniMetadatas, (m) => m.id)
             );
-            this.#storage.next((0, import_lodash_es27.assign)({}, storage, { miniMetadatas }));
+            this.#storage.next((0, import_lodash_es30.assign)({}, storage, { miniMetadatas }));
           })
         );
       }),
       // emit only when mini metadata changes, as a change here would restart all subscriptions for the network
-      (0, import_rxjs15.distinctUntilChanged)(import_lodash_es27.isEqual)
+      (0, import_rxjs16.distinctUntilChanged)(import_lodash_es30.isEqual)
     );
   }
   getStoredMiniMetadatas$(miniMetadataIds) {
     return this.storedMiniMetadataMapById$.pipe(
-      (0, import_rxjs15.map)((mapById) => {
+      (0, import_rxjs16.map)((mapById) => {
         const miniMetadatas = miniMetadataIds.map((id) => mapById[id]);
-        return miniMetadatas.length && miniMetadatas.every(import_util16.isTruthy) ? miniMetadatas : null;
+        return miniMetadatas.length && miniMetadatas.every(import_util15.isTruthy) ? miniMetadatas : null;
       }),
       // source changes very often
-      (0, import_rxjs15.distinctUntilChanged)(import_lodash_es27.isEqual)
+      (0, import_rxjs16.distinctUntilChanged)(import_lodash_es30.isEqual)
     );
   }
   getDefaultMiniMetadatas$(miniMetadataIds) {
     return this.#chaindataProvider.miniMetadatasMapById$.pipe(
-      (0, import_rxjs15.map)((mapById) => {
+      (0, import_rxjs16.map)((mapById) => {
         const miniMetadatas = miniMetadataIds.map((id) => mapById[id]);
-        return miniMetadatas.length && miniMetadatas.every(import_util16.isTruthy) ? miniMetadatas : null;
+        return miniMetadatas.length && miniMetadatas.every(import_util15.isTruthy) ? miniMetadatas : null;
       })
     );
   }
   getStoredBalances(addressesByToken) {
-    const balanceDefs = (0, import_lodash_es27.toPairs)(addressesByToken).flatMap(
+    const balanceDefs = (0, import_lodash_es30.toPairs)(addressesByToken).flatMap(
       ([tokenId, addresses]) => addresses.map((address) => [tokenId, address])
     );
-    return balanceDefs.map(([tokenId, address]) => this.#storage.value.balances[getBalanceId({ address, tokenId })]).filter(import_util16.isNotNil).sort(sortByBalanceId);
+    return balanceDefs.map(([tokenId, address]) => this.#storage.value.balances[getBalanceId({ address, tokenId })]).filter(import_util15.isNotNil).sort(sortByBalanceId);
   }
   cleanupAddressesByTokenId$(addressesByTokenId) {
     return this.#chaindataProvider.getNetworksMapById$().pipe(
-      (0, import_rxjs15.map)((networksById) => {
-        return (0, import_lodash_es27.fromPairs)(
-          (0, import_lodash_es27.toPairs)(addressesByTokenId).map(([tokenId, addresses]) => {
-            const networkId = (0, import_chaindata_provider64.parseTokenId)(tokenId).networkId;
+      (0, import_rxjs16.map)((networksById) => {
+        return (0, import_lodash_es30.fromPairs)(
+          (0, import_lodash_es30.toPairs)(addressesByTokenId).map(([tokenId, addresses]) => {
+            const networkId = (0, import_chaindata_provider71.parseTokenId)(tokenId).networkId;
             const network = networksById[networkId];
             return [
               tokenId,
-              (0, import_lodash_es27.uniq)(addresses.map(import_crypto8.normalizeAddress)).filter(
+              (0, import_lodash_es30.uniq)(addresses.map(import_crypto8.normalizeAddress)).filter(
                 (address) => network && isAddressCompatibleWithNetwork(network, address)
               )
             ];
@@ -7918,7 +8436,7 @@ var sortByBalanceId = (a, b) => getBalanceId(a).localeCompare(getBalanceId(b));
 var sortByMiniMetadataId = (a, b) => a.id.localeCompare(b.id);
 
 // src/version.ts
-var import_chaindata_provider65 = require("@talismn/chaindata-provider");
+var import_chaindata_provider72 = require("@talismn/chaindata-provider");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ALPHA_PRICE_SCALE,
@@ -7942,6 +8460,8 @@ var import_chaindata_provider65 = require("@talismn/chaindata-provider");
   SolNativeTokenConfigSchema,
   SolSplBalanceModule,
   SolSplTokenConfigSchema,
+  SolToken2022BalanceModule,
+  SolToken2022TokenConfigSchema,
   SubAssetsBalanceModule,
   SubAssetsTokenConfigSchema,
   SubDTaoBalanceModule,