@talismn/balances 1.3.6 → 1.4.0

package/dist/index.mjs

@@ -7,20 +7,20 @@ import {
   getAccountPlatformFromAddress,
   normalizeAddress
 } from "@talismn/crypto";
-import { getSharedObservable, isNotNil as isNotNil9, isTruthy, keepAlive } from "@talismn/util";
-import { assign as assign11, fromPairs as fromPairs2, isEqual as isEqual10, keyBy as keyBy8, keys as keys3, toPairs as toPairs2, uniq as uniq5, values as values2 } from "lodash-es";
+import { getSharedObservable, isNotNil as isNotNil10, isTruthy, keepAlive } from "@talismn/util";
+import { assign as assign12, fromPairs as fromPairs2, isEqual as isEqual11, keyBy as keyBy9, keys as keys3, toPairs as toPairs2, uniq as uniq6, values as values2 } from "lodash-es";
 import {
   BehaviorSubject as BehaviorSubject2,
   catchError,
   combineLatest,
   defer,
-  distinctUntilChanged as distinctUntilChanged10,
+  distinctUntilChanged as distinctUntilChanged11,
   EMPTY,
   filter,
   firstValueFrom,
   from,
   map as map6,
-  of as of14,
+  of as of15,
   shareReplay,
   startWith,
   switchMap as switchMap2,
@@ -38,7 +38,7 @@ import anylogger from "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",
@@ -90,7 +90,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"
@@ -98,8 +97,6 @@ var package_default = {
   peerDependencies: {
     "@polkadot/api-contract": "*",
     "@polkadot/types": "*",
-    "@polkadot/util": "*",
-    "@polkadot/util-crypto": "*",
     "@substrate/txwrapper-core": "*"
   },
   types: "./dist/index.d.ts",
@@ -1852,8 +1849,8 @@ var fetchBalances4 = async ({
   const results = await Promise.allSettled(
     balanceDefs.map(async ({ token, address }) => {
       try {
-        const publicKey2 = new PublicKey(address);
-        const lamports = await connection.getBalance(publicKey2);
+        const publicKey3 = new PublicKey(address);
+        const lamports = await connection.getBalance(publicKey3);
         return {
           address,
           tokenId: token.id,
@@ -2009,8 +2006,8 @@ var MODULE_TYPE5 = SolSplTokenSchema.shape.type.value;
 var PLATFORM5 = SolSplTokenSchema.shape.platform.value;
 
 // src/modules/sol-spl/fetchBalances.ts
-import { PublicKey as PublicKey3 } from "@solana/web3.js";
-import { solSplTokenId } from "@talismn/chaindata-provider";
+import { PublicKey as PublicKey4 } from "@solana/web3.js";
+import { SolSplTokenSchema as SolSplTokenSchema3, solSplTokenId } from "@talismn/chaindata-provider";
 import { isNotNil as isNotNil2 } from "@talismn/util";
 import { keyBy as keyBy2, uniq as uniq2 } from "lodash-es";
 
@@ -2172,8 +2169,77 @@ var getDetectedTokensIds$ = (address) => tokenIdsByAddress.pipe(
   distinctUntilChanged5(isEqual5)
 );
 
+// src/modules/sol-spl/onChainTokenMetadata.ts
+import { deserializeMetadata } from "@metaplex-foundation/mpl-token-metadata";
+import { publicKey, sol } from "@metaplex-foundation/umi";
+import { MintLayout } from "@solana/spl-token";
+import { PublicKey as PublicKey3 } from "@solana/web3.js";
+import { parseSolSplTokenId, SolSplTokenSchema as SolSplTokenSchema2 } from "@talismn/chaindata-provider";
+import z7 from "zod/v4";
+var TokenCacheSchema3 = z7.discriminatedUnion("isValid", [
+  z7.strictObject({
+    id: SolSplTokenSchema2.shape.id,
+    isValid: z7.literal(true),
+    ...SolSplTokenSchema2.pick({ symbol: true, decimals: true, name: true, logo: true }).shape
+  }),
+  z7.strictObject({
+    id: SolSplTokenSchema2.shape.id,
+    isValid: z7.literal(false)
+  })
+]);
+var METAPLEX_PROGRAM_ID = new PublicKey3("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 } = parseSolSplTokenId(tokenId);
+    const connection = await connector.getConnection(networkId);
+    if (!connection) {
+      log_default.warn(`No connection found for network ${networkId}`);
+      return null;
+    }
+    const mintPubKey = new PublicKey3(mintAddress);
+    const mintInfo = await connection.getAccountInfo(mintPubKey);
+    if (!mintInfo?.data) throw new Error(ERROR_NO_MINT);
+    const mint = MintLayout.decode(mintInfo.data);
+    const [metadataPDA] = PublicKey3.findProgramAddressSync(
+      [Buffer.from("metadata"), METAPLEX_PROGRAM_ID.toBuffer(), mintPubKey.toBuffer()],
+      METAPLEX_PROGRAM_ID
+    );
+    const metadataAccount = await connection.getAccountInfo(new PublicKey3(metadataPDA));
+    if (!metadataAccount) throw new Error(ERROR_NO_METADATA);
+    const metadata = deserializeMetadata({
+      publicKey: publicKey(metadataPDA),
+      executable: metadataAccount.executable,
+      owner: publicKey(metadataAccount.owner),
+      lamports: sol(metadataAccount.lamports),
+      data: metadataAccount.data
+    });
+    const parsed = 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,
@@ -2183,18 +2249,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 = uniq2(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 PublicKey3(address), {
-        programId: new PublicKey3(SPL_PROGRAM_ID)
+      const tokenAccounts = await connection.getParsedTokenAccountsByOwner(new PublicKey4(address), {
+        programId: new PublicKey4(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 = solSplTokenId(networkId, mintAddress);
+          if (!knownTokenIds.has(tokenId) && value !== "0") unknownMints.add(mintAddress);
           return {
-            tokenId: solSplTokenId(networkId, mintAddress),
+            tokenId,
             networkId,
             address,
             source: MODULE_TYPE5,
@@ -2217,6 +2287,42 @@ var fetchBalances5 = async ({
       return [address, balances];
     })
   );
+  const dynamicTokens = [];
+  if (unknownMints.size) {
+    await Promise.all(
+      Array.from(unknownMints).map(async (mintAddress) => {
+        const tokenId = 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 = SolSplTokenSchema3.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 = keyBy2(
     balancesPerAddress.flatMap(([, addressBalances]) => addressBalances),
     (b) => getBalanceKey(b.tokenId, b.address)
@@ -2233,34 +2339,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
-import { deserializeMetadata } from "@metaplex-foundation/mpl-token-metadata";
-import { publicKey, sol } from "@metaplex-foundation/umi";
-import { MintLayout } from "@solana/spl-token";
-import { PublicKey as PublicKey4 } from "@solana/web3.js";
-import {
-  parseSolSplTokenId,
-  SolSplTokenSchema as SolSplTokenSchema2,
-  solSplTokenId as solSplTokenId2
-} from "@talismn/chaindata-provider";
+import { SolSplTokenSchema as SolSplTokenSchema4, solSplTokenId as solSplTokenId2 } from "@talismn/chaindata-provider";
 import { assign as assign5, omit as omit3 } from "lodash-es";
-import z7 from "zod/v4";
-var TokenCacheSchema3 = z7.discriminatedUnion("isValid", [
-  z7.strictObject({
-    id: SolSplTokenSchema2.shape.id,
-    isValid: z7.literal(true),
-    ...SolSplTokenSchema2.pick({ symbol: true, decimals: true, name: true, logo: true }).shape
-  }),
-  z7.strictObject({
-    id: SolSplTokenSchema2.shape.id,
-    isValid: z7.literal(false)
-  })
-]);
-var METAPLEX_PROGRAM_ID = new PublicKey4("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
 var fetchTokens5 = async ({
   networkId,
   tokens,
@@ -2288,7 +2376,7 @@ var fetchTokens5 = async ({
       cached?.isValid ? omit3(cached, ["isValid"]) : {},
       tokenConfig
     );
-    const parsed = SolSplTokenSchema2.safeParse(token);
+    const parsed = SolSplTokenSchema4.safeParse(token);
     if (!parsed.success) {
       log_default.warn("Ignoring token with invalid SolSplTokenSchema", {
         token
@@ -2299,54 +2387,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 } = parseSolSplTokenId(tokenId);
-    const connection = await connector.getConnection(networkId);
-    if (!connection) {
-      log_default.warn(`No connection found for network ${networkId}`);
-      return null;
-    }
-    const mintPubKey = new PublicKey4(mintAddress);
-    const mintInfo = await connection.getAccountInfo(mintPubKey);
-    if (!mintInfo?.data) throw new Error(ERROR_NO_MINT);
-    const mint = MintLayout.decode(mintInfo.data);
-    const [metadataPDA] = PublicKey4.findProgramAddressSync(
-      [Buffer.from("metadata"), METAPLEX_PROGRAM_ID.toBuffer(), mintPubKey.toBuffer()],
-      METAPLEX_PROGRAM_ID
-    );
-    const metadataAccount = await connection.getAccountInfo(new PublicKey4(metadataPDA));
-    if (!metadataAccount) throw new Error(ERROR_NO_METADATA);
-    const metadata = deserializeMetadata({
-      publicKey: publicKey(metadataPDA),
-      executable: metadataAccount.executable,
-      owner: publicKey(metadataAccount.owner),
-      lamports: sol(metadataAccount.lamports),
-      data: metadataAccount.data
-    });
-    const parsed = 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 = () => {
@@ -2457,21 +2497,496 @@ var SolSplBalanceModule = {
 };
 
 // src/modules/sol-spl/types.ts
-import { SolSplTokenSchema as SolSplTokenSchema3 } from "@talismn/chaindata-provider";
+import { SolSplTokenSchema as SolSplTokenSchema5 } from "@talismn/chaindata-provider";
 import z8 from "zod/v4";
 var SolSplTokenConfigSchema = z8.strictObject({
-  mintAddress: SolSplTokenSchema3.shape.mintAddress,
+  mintAddress: SolSplTokenSchema5.shape.mintAddress,
+  ...TokenConfigBaseSchema.shape
+});
+
+// src/modules/sol-token2022/config.ts
+import { SolToken2022TokenSchema } from "@talismn/chaindata-provider";
+var MODULE_TYPE6 = SolToken2022TokenSchema.shape.type.value;
+var PLATFORM6 = SolToken2022TokenSchema.shape.platform.value;
+
+// src/modules/sol-token2022/fetchBalances.ts
+import { PublicKey as PublicKey7 } from "@solana/web3.js";
+import {
+  SolToken2022TokenSchema as SolToken2022TokenSchema3,
+  solToken2022TokenId
+} from "@talismn/chaindata-provider";
+import { isNotNil as isNotNil3 } from "@talismn/util";
+import { keyBy as keyBy3, uniq as uniq3 } from "lodash-es";
+
+// src/modules/sol-token2022/onChainTokenMetadata.ts
+import { deserializeMetadata as deserializeMetadata2 } from "@metaplex-foundation/mpl-token-metadata";
+import { publicKey as publicKey2, sol as sol2 } from "@metaplex-foundation/umi";
+import { MintLayout as MintLayout2 } from "@solana/spl-token";
+import { PublicKey as PublicKey6 } from "@solana/web3.js";
+import { parseSolToken2022TokenId, SolToken2022TokenSchema as SolToken2022TokenSchema2 } from "@talismn/chaindata-provider";
+import z9 from "zod/v4";
+var TokenCacheSchema4 = z9.discriminatedUnion("isValid", [
+  z9.strictObject({
+    id: SolToken2022TokenSchema2.shape.id,
+    isValid: z9.literal(true),
+    ...SolToken2022TokenSchema2.pick({ symbol: true, decimals: true, name: true, logo: true }).shape
+  }),
+  z9.strictObject({
+    id: SolToken2022TokenSchema2.shape.id,
+    isValid: z9.literal(false)
+  })
+]);
+var METAPLEX_PROGRAM_ID2 = new PublicKey6("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 } = parseSolToken2022TokenId(tokenId);
+    const connection = await connector.getConnection(networkId);
+    if (!connection) {
+      log_default.warn(`No connection found for network ${networkId}`);
+      return null;
+    }
+    const mintPubKey = new PublicKey6(mintAddress);
+    const mintInfo = await connection.getAccountInfo(mintPubKey);
+    if (!mintInfo?.data) throw new Error(ERROR_NO_MINT2);
+    const mint = MintLayout2.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] = PublicKey6.findProgramAddressSync(
+      [Buffer.from("metadata"), METAPLEX_PROGRAM_ID2.toBuffer(), mintPubKey.toBuffer()],
+      METAPLEX_PROGRAM_ID2
+    );
+    const metadataAccount = await connection.getAccountInfo(new PublicKey6(metadataPDA));
+    if (!metadataAccount) throw new Error(ERROR_NO_METADATA2);
+    const metadata = deserializeMetadata2({
+      publicKey: publicKey2(metadataPDA),
+      executable: metadataAccount.executable,
+      owner: publicKey2(metadataAccount.owner),
+      lamports: sol2(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 = uniq3(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 PublicKey7(address), {
+        programId: new PublicKey7(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 = 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(isNotNil3);
+      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 = 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 = SolToken2022TokenSchema3.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 = keyBy3(
+    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
+import {
+  SolToken2022TokenSchema as SolToken2022TokenSchema4,
+  solToken2022TokenId as solToken2022TokenId2
+} from "@talismn/chaindata-provider";
+import { assign as assign6, omit as omit4 } from "lodash-es";
+var fetchTokens6 = async ({
+  networkId,
+  tokens,
+  connector,
+  cache
+}) => {
+  const result = [];
+  for (const tokenConfig of tokens) {
+    const tokenId = solToken2022TokenId2(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 = assign6(
+      base,
+      cached?.isValid ? omit4(cached, ["isValid"]) : {},
+      tokenConfig
+    );
+    const parsed = SolToken2022TokenSchema4.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
+import {
+  calculateEpochFee,
+  createAssociatedTokenAccountInstruction as createAssociatedTokenAccountInstruction2,
+  createTransferCheckedInstruction,
+  createTransferCheckedWithFeeAndTransferHookInstruction,
+  createTransferCheckedWithFeeInstruction,
+  createTransferCheckedWithTransferHookInstruction,
+  getAccount as getAccount2,
+  getAssociatedTokenAddress as getAssociatedTokenAddress2,
+  getMint,
+  getNonTransferable,
+  getTransferFeeConfig,
+  getTransferHook,
+  TOKEN_2022_PROGRAM_ID as TOKEN_2022_PROGRAM_ID2
+} from "@solana/spl-token";
+import { PublicKey as PublicKey8 } from "@solana/web3.js";
+import { isTokenOfType as isTokenOfType6 } from "@talismn/chaindata-provider";
+var getTransferCallData6 = async ({ from: from2, to, value, token, connector }) => {
+  if (!isTokenOfType6(token, MODULE_TYPE6))
+    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE6}.`);
+  const connection = await connector.getConnection(token.networkId);
+  const mintPubkey = new PublicKey8(token.mintAddress);
+  const fromWallet = new PublicKey8(from2);
+  const toWallet = new PublicKey8(to);
+  const mintAccount = await getMint(connection, mintPubkey, void 0, TOKEN_2022_PROGRAM_ID2);
+  const nonTransferable = getNonTransferable(mintAccount);
+  if (nonTransferable) throw new Error("This token is non-transferable.");
+  const transferFeeConfig = getTransferFeeConfig(mintAccount);
+  const transferHook = getTransferHook(mintAccount);
+  const instructions = [];
+  const fromTokenAccount = await getAssociatedTokenAddress2(
+    mintPubkey,
+    fromWallet,
+    false,
+    TOKEN_2022_PROGRAM_ID2
+  );
+  const toTokenAccount = await getAssociatedTokenAddress2(
+    mintPubkey,
+    toWallet,
+    false,
+    TOKEN_2022_PROGRAM_ID2
+  );
+  if (!await tokenAccountExists2(connection, toTokenAccount)) {
+    instructions.push(
+      createAssociatedTokenAccountInstruction2(
+        fromWallet,
+        toTokenAccount,
+        toWallet,
+        mintPubkey,
+        TOKEN_2022_PROGRAM_ID2
+      )
+    );
+  }
+  const amount = BigInt(value);
+  const transferFee = transferFeeConfig ? await calculateCurrentEpochTransferFee(connection, transferFeeConfig, amount) : 0n;
+  if (transferFeeConfig && transferHook) {
+    instructions.push(
+      await createTransferCheckedWithFeeAndTransferHookInstruction(
+        connection,
+        fromTokenAccount,
+        mintPubkey,
+        toTokenAccount,
+        fromWallet,
+        amount,
+        token.decimals,
+        transferFee,
+        [],
+        void 0,
+        TOKEN_2022_PROGRAM_ID2
+      )
+    );
+  } else if (transferFeeConfig) {
+    instructions.push(
+      createTransferCheckedWithFeeInstruction(
+        fromTokenAccount,
+        mintPubkey,
+        toTokenAccount,
+        fromWallet,
+        amount,
+        token.decimals,
+        transferFee,
+        [],
+        TOKEN_2022_PROGRAM_ID2
+      )
+    );
+  } else if (transferHook) {
+    instructions.push(
+      await createTransferCheckedWithTransferHookInstruction(
+        connection,
+        fromTokenAccount,
+        mintPubkey,
+        toTokenAccount,
+        fromWallet,
+        amount,
+        token.decimals,
+        [],
+        void 0,
+        TOKEN_2022_PROGRAM_ID2
+      )
+    );
+  } else {
+    instructions.push(
+      createTransferCheckedInstruction(
+        fromTokenAccount,
+        mintPubkey,
+        toTokenAccount,
+        fromWallet,
+        amount,
+        token.decimals,
+        [],
+        TOKEN_2022_PROGRAM_ID2
+      )
+    );
+  }
+  return instructions;
+};
+var tokenAccountExists2 = async (connection, address) => {
+  try {
+    await getAccount2(connection, address, void 0, TOKEN_2022_PROGRAM_ID2);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var calculateToken2022TransferFee = (transferFeeConfig, epoch, amount) => {
+  return 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
+import { isEqual as isEqual7 } from "lodash-es";
+import { distinctUntilChanged as distinctUntilChanged7, Observable as Observable7, of as of7 } from "rxjs";
+var SUBSCRIPTION_INTERVAL6 = 6e3;
+var subscribeBalances6 = ({
+  networkId,
+  tokensWithAddresses,
+  connector
+}) => {
+  if (!tokensWithAddresses.length) return of7({ success: [], errors: [] });
+  return new Observable7((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(distinctUntilChanged7(isEqual7));
+};
+
+// 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
+import { SolToken2022TokenSchema as SolToken2022TokenSchema5 } from "@talismn/chaindata-provider";
+import z10 from "zod/v4";
+var SolToken2022TokenConfigSchema = z10.strictObject({
+  mintAddress: SolToken2022TokenSchema5.shape.mintAddress,
   ...TokenConfigBaseSchema.shape
 });
 
 // src/modules/substrate-assets/config.ts
 import { SubAssetsTokenSchema } from "@talismn/chaindata-provider";
-var MODULE_TYPE6 = SubAssetsTokenSchema.shape.type.value;
-var PLATFORM6 = SubAssetsTokenSchema.shape.platform.value;
+var MODULE_TYPE7 = SubAssetsTokenSchema.shape.type.value;
+var PLATFORM7 = SubAssetsTokenSchema.shape.platform.value;
 
 // src/modules/substrate-assets/buildQueries.ts
 import { decodeScale } from "@talismn/scale";
-import { isNotNil as isNotNil3 } from "@talismn/util";
+import { isNotNil as isNotNil4 } from "@talismn/util";
 var buildQueries = (networkId, balanceDefs, miniMetadata) => {
   const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
     storage: ["Assets", "Account"]
@@ -2520,7 +3035,7 @@ var buildQueries = (networkId, balanceDefs, miniMetadata) => {
       stateKeys: [stateKey],
       decodeResult
     };
-  }).filter(isNotNil3);
+  }).filter(isNotNil4);
 };
 var tryEncode = (scaleCoder, ...args) => {
   try {
@@ -2531,7 +3046,7 @@ var tryEncode = (scaleCoder, ...args) => {
 };
 
 // src/modules/substrate-assets/fetchBalances.ts
-var fetchBalances6 = async ({
+var fetchBalances7 = async ({
   networkId,
   tokensWithAddresses,
   connector,
@@ -2540,7 +3055,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) => ({
@@ -2550,20 +3065,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: [],
@@ -2587,7 +3102,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" },
@@ -2606,8 +3121,8 @@ import {
   subAssetTokenId
 } from "@talismn/chaindata-provider";
 import { getStorageKeyPrefix, parseMetadataRpc as parseMetadataRpc3 } from "@talismn/scale";
-import { assign as assign6, keyBy as keyBy3, keys } from "lodash-es";
-var fetchTokens6 = async ({
+import { assign as assign7, keyBy as keyBy4, keys } from "lodash-es";
+var fetchTokens7 = async ({
   networkId,
   tokens,
   connector,
@@ -2632,7 +3147,7 @@ var fetchTokens6 = async ({
   ]);
   const assetStorageEntries = assetStorageResults.length ? assetStorageResults[0].changes : [];
   const metadataStorageEntries = metadataStorageResults.length ? metadataStorageResults[0].changes : [];
-  const assetByAssetId = keyBy3(
+  const assetByAssetId = keyBy4(
     assetStorageEntries.map(([key, value]) => {
       const [assetId] = assetCodec.keys.dec(key);
       const asset = assetCodec.value.dec(value);
@@ -2640,7 +3155,7 @@ var fetchTokens6 = async ({
     }),
     (a) => a.assetId
   );
-  const metadataByAssetId = keyBy3(
+  const metadataByAssetId = keyBy4(
     metadataStorageEntries.map(([key, value]) => {
       const [assetId] = metadataCodec.keys.dec(key);
       const metadata = metadataCodec.value.dec(value);
@@ -2655,13 +3170,13 @@ var fetchTokens6 = async ({
     (a) => a.assetId
   );
   const allTokens = keys(assetByAssetId).map(
-    (assetId) => assign6({}, assetByAssetId[assetId], metadataByAssetId[assetId] ?? void 0)
+    (assetId) => assign7({}, assetByAssetId[assetId], metadataByAssetId[assetId] ?? void 0)
   );
-  const configTokenByAssetId = keyBy3(tokens, (t) => t.assetId);
+  const configTokenByAssetId = keyBy4(tokens, (t) => t.assetId);
   return allTokens.map(
     (asset) => ({
       id: subAssetTokenId(networkId, String(asset.assetId)),
-      type: MODULE_TYPE6,
+      type: MODULE_TYPE7,
       platform: "polkadot",
       networkId,
       assetId: String(asset.assetId),
@@ -2678,7 +3193,7 @@ var fetchTokens6 = async ({
     return configToken || token.isSufficient;
   }).map((token) => {
     const configToken = configTokenByAssetId[token.assetId];
-    return configToken ? assign6({}, token, configToken) : token;
+    return configToken ? assign7({}, token, configToken) : token;
   }).filter((t) => {
     const parsed = SubAssetsTokenSchema2.safeParse(t);
     return parsed.success;
@@ -2754,8 +3269,8 @@ var getDTaoTokenRates = (token, tokenRates, scaledAlphaPrice) => {
 
 // src/modules/substrate-dtao/config.ts
 import { SubDTaoTokenSchema } from "@talismn/chaindata-provider";
-var MODULE_TYPE7 = SubDTaoTokenSchema.shape.type.value;
-var PLATFORM7 = SubDTaoTokenSchema.shape.platform.value;
+var MODULE_TYPE8 = SubDTaoTokenSchema.shape.type.value;
+var PLATFORM8 = SubDTaoTokenSchema.shape.platform.value;
 
 // src/modules/substrate-dtao/fetchBalances.ts
 import {
@@ -2764,8 +3279,8 @@ import {
   TokenSchema
 } from "@talismn/chaindata-provider";
 import { decodeScale as decodeScale2, parseMetadataRpc as parseMetadataRpc4 } from "@talismn/scale";
-import { isNotNil as isNotNil4 } from "@talismn/util";
-import { keyBy as keyBy4, uniq as uniq3 } from "lodash-es";
+import { isNotNil as isNotNil5 } from "@talismn/util";
+import { keyBy as keyBy5, uniq as uniq4 } from "lodash-es";
 
 // src/modules/substrate-dtao/calculatePendingRootClaimable.ts
 import { subDTaoTokenId } from "@talismn/chaindata-provider";
@@ -2804,7 +3319,7 @@ var calculatePendingRootClaimable = ({
 
 // src/modules/substrate-dtao/fetchBalances.ts
 var ROOT_NETUID = 0;
-var fetchBalances7 = async ({
+var fetchBalances8 = async ({
   networkId,
   tokensWithAddresses,
   connector,
@@ -2813,7 +3328,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 {
@@ -2825,20 +3340,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: [],
@@ -2849,7 +3364,7 @@ var fetchBalances7 = async ({
       }))
     };
   }
-  const addresses = uniq3(balanceDefs.map((def) => def.address));
+  const addresses = uniq4(balanceDefs.map((def) => def.address));
   try {
     const [stakeInfos, dynamicInfos] = await Promise.all([
       fetchRuntimeCallResult(
@@ -2869,7 +3384,7 @@ var fetchBalances7 = async ({
         []
       )
     ]);
-    const rootHotkeys = uniq3(
+    const rootHotkeys = uniq4(
       stakeInfos.flatMap(
         ([, stakes]) => stakes.filter((stake) => stake.netuid === ROOT_NETUID).map((stake) => stake.hotkey)
       )
@@ -2894,7 +3409,7 @@ var fetchBalances7 = async ({
       miniMetadata.data,
       addressHotkeyNetuidPairs
     ) : /* @__PURE__ */ new Map();
-    const dynamicInfoByNetuid = keyBy4(dynamicInfos.filter(isNotNil4), (info) => info.netuid);
+    const dynamicInfoByNetuid = keyBy5(dynamicInfos.filter(isNotNil5), (info) => info.netuid);
     const upsertBalance = (acc, address, tokenId, balance) => {
       const key = `${address}:${tokenId}`;
       const recordedBalance = acc[key];
@@ -2948,7 +3463,7 @@ var fetchBalances7 = async ({
       {}
     );
     const balances = Object.values(balancesRaw);
-    const tokensById = keyBy4(
+    const tokensById = keyBy5(
       tokensWithAddresses.map(([token]) => token),
       (t) => t.id
     );
@@ -3002,7 +3517,7 @@ var fetchBalances7 = async ({
         address: def.address,
         networkId,
         tokenId: def.token.id,
-        source: MODULE_TYPE7,
+        source: MODULE_TYPE8,
         status: "live",
         values: values3
       };
@@ -3174,13 +3689,13 @@ import {
   subDTaoTokenId as subDTaoTokenId3
 } from "@talismn/chaindata-provider";
 import { getStorageKeyPrefix as getStorageKeyPrefix2, parseMetadataRpc as parseMetadataRpc5 } from "@talismn/scale";
-import { isNotNil as isNotNil5 } from "@talismn/util";
+import { isNotNil as isNotNil6 } from "@talismn/util";
 import { fromPairs } from "lodash-es";
 var NATIVE_TOKEN_SYMBOLS = {
   "bittensor": "TAO",
   "bittensor-testnet": "testTAO"
 };
-var fetchTokens7 = async ({
+var fetchTokens8 = async ({
   networkId,
   connector,
   tokens,
@@ -3199,7 +3714,7 @@ var fetchTokens7 = async ({
       []
     )
   ]);
-  return dynamicInfos.filter(isNotNil5).map((info) => {
+  return dynamicInfos.filter(isNotNil6).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}`);
@@ -3209,8 +3724,8 @@ var fetchTokens7 = async ({
     const isTransferable = transferableTokensMap[info.netuid] ?? true;
     const token = {
       id: subDTaoTokenId3(networkId, info.netuid),
-      type: MODULE_TYPE7,
-      platform: PLATFORM7,
+      type: MODULE_TYPE8,
+      platform: PLATFORM8,
       networkId,
       netuid: info.netuid,
       isDefault: true,
@@ -3250,12 +3765,12 @@ var fetchTransferableTokensMap = async (connector, metadata, networkId) => {
 // src/modules/substrate-dtao/getMiniMetadata.ts
 import { MINIMETADATA_VERSION } from "@talismn/chaindata-provider";
 import { compactMetadata, encodeMetadata, parseMetadataRpc as parseMetadataRpc6 } from "@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)
@@ -3301,18 +3816,18 @@ var getData = (metadataRpc) => {
 
 // src/modules/substrate-dtao/getTransferCallData.ts
 import { mergeUint8 } from "@polkadot-api/utils";
-import { isTokenOfType as isTokenOfType6, parseSubDTaoTokenId } from "@talismn/chaindata-provider";
+import { isTokenOfType as isTokenOfType7, parseSubDTaoTokenId } from "@talismn/chaindata-provider";
 import { parseMetadataRpc as parseMetadataRpc7 } from "@talismn/scale";
 import { Binary } from "polkadot-api";
-var getTransferCallData6 = ({
+var getTransferCallData7 = ({
   from: from2,
   to,
   value,
   token,
   metadataRpc
 }) => {
-  if (!isTokenOfType6(token, MODULE_TYPE7))
-    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE7}.`);
+  if (!isTokenOfType7(token, MODULE_TYPE8))
+    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE8}.`);
   const { netuid: subnetId, hotkey } = parseSubDTaoTokenId(token.id);
   if (!hotkey) throw new Error(`Missing hotkey`);
   const { builder } = parseMetadataRpc7(metadataRpc);
@@ -3332,22 +3847,22 @@ var getTransferCallData6 = ({
 };
 
 // src/modules/substrate-dtao/subscribeBalances.ts
-import { isEqual as isEqual7 } from "lodash-es";
-import { distinctUntilChanged as distinctUntilChanged7, Observable as Observable7, of as of7 } from "rxjs";
-var SUBSCRIPTION_INTERVAL6 = 6e3;
-var subscribeBalances6 = ({
+import { isEqual as isEqual8 } from "lodash-es";
+import { distinctUntilChanged as distinctUntilChanged8, Observable as Observable8, of as of8 } from "rxjs";
+var SUBSCRIPTION_INTERVAL7 = 6e3;
+var subscribeBalances7 = ({
   networkId,
   tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
-  if (!tokensWithAddresses.length) return of7({ success: [], errors: [] });
-  return new Observable7((subscriber) => {
+  if (!tokensWithAddresses.length) return of8({ success: [], errors: [] });
+  return new Observable8((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,
@@ -3355,10 +3870,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,
@@ -3371,24 +3886,24 @@ var subscribeBalances6 = ({
     return () => {
       abortController.abort();
     };
-  }).pipe(distinctUntilChanged7(isEqual7));
+  }).pipe(distinctUntilChanged8(isEqual8));
 };
 
 // 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
 import { SubDTaoTokenSchema as SubDTaoTokenSchema3 } from "@talismn/chaindata-provider";
-import z9 from "zod/v4";
-var SubDTaoTokenConfigSchema = z9.strictObject({
+import z11 from "zod/v4";
+var SubDTaoTokenConfigSchema = z11.strictObject({
   netuid: SubDTaoTokenSchema3.shape.netuid,
   ...TokenConfigBaseSchema.shape
 });
@@ -4056,12 +4571,12 @@ var deriveMiniMetadataId = ({
 ).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)
@@ -4093,10 +4608,10 @@ var getData2 = (metadataRpc) => {
 
 // src/modules/substrate-assets/getTransferCallData.ts
 import { mergeUint8 as mergeUint82 } from "@polkadot-api/utils";
-import { isTokenOfType as isTokenOfType7 } from "@talismn/chaindata-provider";
+import { isTokenOfType as isTokenOfType8 } from "@talismn/chaindata-provider";
 import { parseMetadataRpc as parseMetadataRpc9 } from "@talismn/scale";
 import { Binary as Binary2, Enum } from "polkadot-api";
-var getTransferCallData7 = ({
+var getTransferCallData8 = ({
   from: from2,
   to,
   value,
@@ -4104,8 +4619,8 @@ var getTransferCallData7 = ({
   type,
   metadataRpc
 }) => {
-  if (!isTokenOfType7(token, MODULE_TYPE6))
-    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE6}.`);
+  if (!isTokenOfType8(token, MODULE_TYPE7))
+    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE7}.`);
   const { builder } = parseMetadataRpc9(metadataRpc);
   const method = getTransferMethod(type);
   const { codec, location } = builder.buildCall("Assets", method);
@@ -4194,14 +4709,14 @@ var getTransferAllEncodedArgs = (assetId, to, codec) => {
 };
 
 // src/modules/substrate-assets/subscribeBalances.ts
-import { map as map2, of as of8 } from "rxjs";
-var subscribeBalances7 = ({
+import { map as map2, of as of9 } from "rxjs";
+var subscribeBalances8 = ({
   networkId,
   tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
-  if (!tokensWithAddresses.length) return of8({ success: [], errors: [] });
+  if (!tokensWithAddresses.length) return of9({ success: [], errors: [] });
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   const queries = buildQueries(networkId, balanceDefs, miniMetadata);
   return getRpcQueryPack$(connector, networkId, queries).pipe(
@@ -4214,31 +4729,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
 import { SubAssetsTokenSchema as SubAssetsTokenSchema3 } from "@talismn/chaindata-provider";
-import z10 from "zod/v4";
-var SubAssetsTokenConfigSchema = z10.strictObject({
+import z12 from "zod/v4";
+var SubAssetsTokenConfigSchema = z12.strictObject({
   assetId: SubAssetsTokenSchema3.shape.assetId,
   ...TokenConfigBaseSchema.shape
 });
 
 // src/modules/substrate-foreignassets/config.ts
 import { SubForeignAssetsTokenSchema } from "@talismn/chaindata-provider";
-var MODULE_TYPE8 = SubForeignAssetsTokenSchema.shape.type.value;
-var PLATFORM8 = SubForeignAssetsTokenSchema.shape.platform.value;
+var MODULE_TYPE9 = SubForeignAssetsTokenSchema.shape.type.value;
+var PLATFORM9 = SubForeignAssetsTokenSchema.shape.platform.value;
 
 // src/modules/substrate-foreignassets/buildQueries.ts
 import { decodeScale as decodeScale3, papiParse } from "@talismn/scale";
-import { isNotNil as isNotNil6 } from "@talismn/util";
+import { isNotNil as isNotNil7 } from "@talismn/util";
 var buildQueries2 = (networkId, balanceDefs, miniMetadata) => {
   const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
     storage: ["ForeignAssets", "Account"]
@@ -4293,11 +4808,11 @@ var buildQueries2 = (networkId, balanceDefs, miniMetadata) => {
       stateKeys: [stateKey],
       decodeResult
     };
-  }).filter(isNotNil6);
+  }).filter(isNotNil7);
 };
 
 // src/modules/substrate-foreignassets/fetchBalances.ts
-var fetchBalances8 = async ({
+var fetchBalances9 = async ({
   networkId,
   tokensWithAddresses,
   connector,
@@ -4306,7 +4821,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) => ({
@@ -4316,20 +4831,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: [],
@@ -4353,7 +4868,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" },
@@ -4372,8 +4887,8 @@ import {
   subForeignAssetTokenId
 } from "@talismn/chaindata-provider";
 import { getStorageKeyPrefix as getStorageKeyPrefix3, papiStringify, parseMetadataRpc as parseMetadataRpc10 } from "@talismn/scale";
-import { assign as assign7, keyBy as keyBy5, keys as keys2 } from "lodash-es";
-var fetchTokens8 = async ({
+import { assign as assign8, keyBy as keyBy6, keys as keys2 } from "lodash-es";
+var fetchTokens9 = async ({
   networkId,
   tokens,
   connector,
@@ -4398,7 +4913,7 @@ var fetchTokens8 = async ({
   ]);
   const assetStorageEntries = assetStorageResults[0]?.changes ?? [];
   const metadataStorageEntries = metadataStorageResults[0]?.changes ?? [];
-  const assetByOnChainId = keyBy5(
+  const assetByOnChainId = keyBy6(
     assetStorageEntries.map(([key, value]) => {
       const [decodedKey] = assetCodec.keys.dec(key);
       const onChainId = papiStringify(decodedKey);
@@ -4407,7 +4922,7 @@ var fetchTokens8 = async ({
     }),
     (a) => a.onChainId
   );
-  const metadataByOnChainId = keyBy5(
+  const metadataByOnChainId = keyBy6(
     metadataStorageEntries.map(([key, value]) => {
       const [decodedKey] = metadataCodec.keys.dec(key);
       const onChainId = papiStringify(decodedKey);
@@ -4423,13 +4938,13 @@ var fetchTokens8 = async ({
     (a) => a.onChainId
   );
   const allTokens = keys2(assetByOnChainId).map(
-    (onChainId) => assign7({}, assetByOnChainId[onChainId], metadataByOnChainId[onChainId] ?? void 0)
+    (onChainId) => assign8({}, assetByOnChainId[onChainId], metadataByOnChainId[onChainId] ?? void 0)
   );
-  const configTokenByOnChainId = keyBy5(tokens, (t) => t.onChainId);
+  const configTokenByOnChainId = keyBy6(tokens, (t) => t.onChainId);
   return allTokens.map(
     (asset) => ({
       id: subForeignAssetTokenId(networkId, asset.onChainId),
-      type: MODULE_TYPE8,
+      type: MODULE_TYPE9,
       platform: "polkadot",
       networkId,
       onChainId: String(asset.onChainId),
@@ -4446,7 +4961,7 @@ var fetchTokens8 = async ({
     return configToken || token.isSufficient;
   }).map((token) => {
     const configToken = configTokenByOnChainId[token.onChainId];
-    return configToken ? assign7({}, token, configToken) : token;
+    return configToken ? assign8({}, token, configToken) : token;
   }).filter((t) => {
     const parsed = SubForeignAssetsTokenSchema2.safeParse(t);
     return parsed.success;
@@ -4456,12 +4971,12 @@ var fetchTokens8 = async ({
 // src/modules/substrate-foreignassets/getMiniMetadata.ts
 import { MINIMETADATA_VERSION as MINIMETADATA_VERSION4 } from "@talismn/chaindata-provider";
 import { compactMetadata as compactMetadata3, encodeMetadata as encodeMetadata3, parseMetadataRpc as parseMetadataRpc11 } from "@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)
@@ -4494,10 +5009,10 @@ var getData3 = (metadataRpc) => {
 
 // src/modules/substrate-foreignassets/getTransferCallData.ts
 import { mergeUint8 as mergeUint83 } from "@polkadot-api/utils";
-import { isTokenOfType as isTokenOfType8 } from "@talismn/chaindata-provider";
+import { isTokenOfType as isTokenOfType9 } from "@talismn/chaindata-provider";
 import { papiParse as papiParse2, parseMetadataRpc as parseMetadataRpc12 } from "@talismn/scale";
 import { Binary as Binary3, Enum as Enum2 } from "polkadot-api";
-var getTransferCallData8 = ({
+var getTransferCallData9 = ({
   from: from2,
   to,
   value,
@@ -4505,8 +5020,8 @@ var getTransferCallData8 = ({
   type,
   metadataRpc
 }) => {
-  if (!isTokenOfType8(token, MODULE_TYPE8))
-    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE8}.`);
+  if (!isTokenOfType9(token, MODULE_TYPE9))
+    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE9}.`);
   const { builder } = parseMetadataRpc12(metadataRpc);
   const method = getTransferMethod2(type);
   const { codec, location } = builder.buildCall("ForeignAssets", method);
@@ -4585,14 +5100,14 @@ var getTransferAllEncodedArgs2 = (onChainId, to, codec) => {
 };
 
 // src/modules/substrate-foreignassets/subscribeBalances.ts
-import { map as map3, of as of9 } from "rxjs";
-var subscribeBalances8 = ({
+import { map as map3, of as of10 } from "rxjs";
+var subscribeBalances9 = ({
   networkId,
   tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
-  if (!tokensWithAddresses.length) return of9({ success: [], errors: [] });
+  if (!tokensWithAddresses.length) return of10({ success: [], errors: [] });
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   const queries = buildQueries2(networkId, balanceDefs, miniMetadata);
   return getRpcQueryPack$(connector, networkId, queries).pipe(
@@ -4605,31 +5120,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
 import { SubForeignAssetsTokenSchema as SubForeignAssetsTokenSchema3 } from "@talismn/chaindata-provider";
-import z11 from "zod/v4";
-var SubForeignAssetsTokenConfigSchema = z11.strictObject({
+import z13 from "zod/v4";
+var SubForeignAssetsTokenConfigSchema = z13.strictObject({
   onChainId: SubForeignAssetsTokenSchema3.shape.onChainId,
   ...TokenConfigBaseSchema.shape
 });
 
 // src/modules/substrate-hydration/config.ts
 import { SubHydrationTokenSchema } from "@talismn/chaindata-provider";
-var MODULE_TYPE9 = SubHydrationTokenSchema.shape.type.value;
-var PLATFORM9 = SubHydrationTokenSchema.shape.platform.value;
+var MODULE_TYPE10 = SubHydrationTokenSchema.shape.type.value;
+var PLATFORM10 = SubHydrationTokenSchema.shape.platform.value;
 
 // src/modules/substrate-hydration/fetchBalances.ts
-import { keyBy as keyBy6, uniq as uniq4 } from "lodash-es";
-var fetchBalances9 = async ({
+import { keyBy as keyBy7, uniq as uniq5 } from "lodash-es";
+var fetchBalances10 = async ({
   networkId,
   tokensWithAddresses,
   connector,
@@ -4638,7 +5153,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 {
@@ -4650,20 +5165,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: [],
@@ -4674,7 +5189,7 @@ var fetchBalances9 = async ({
       }))
     };
   }
-  const addresses = uniq4(balanceDefs.map((def) => def.address));
+  const addresses = uniq5(balanceDefs.map((def) => def.address));
   try {
     const res = await Promise.all(
       addresses.map(
@@ -4690,16 +5205,16 @@ var fetchBalances9 = async ({
         frozen: balance.frozen.toString()
       })).filter((b) => b.onChainId !== void 0);
     });
-    const balancesByKey = keyBy6(fetchedBalances, (b) => `${b.address}:${b.onChainId}`);
+    const balancesByKey = keyBy7(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: [
               {
@@ -4747,8 +5262,8 @@ import {
   subHydrationTokenId
 } from "@talismn/chaindata-provider";
 import { getStorageKeyPrefix as getStorageKeyPrefix4, parseMetadataRpc as parseMetadataRpc13 } from "@talismn/scale";
-import { assign as assign8, keyBy as keyBy7 } from "lodash-es";
-var fetchTokens9 = async ({
+import { assign as assign9, keyBy as keyBy8 } from "lodash-es";
+var fetchTokens10 = async ({
   networkId,
   tokens,
   connector,
@@ -4767,7 +5282,7 @@ var fetchTokens9 = async ({
     [allAssetStorageKeys]
   );
   const assetStorageEntries = assetStorageResults.length ? assetStorageResults[0].changes : [];
-  const configTokenByAssetId = keyBy7(tokens, (t) => t.onChainId);
+  const configTokenByAssetId = keyBy8(tokens, (t) => t.onChainId);
   return assetStorageEntries.map(([key, value]) => {
     const [onChainId] = assetsCodec.keys.dec(key);
     const asset = assetsCodec.value.dec(value);
@@ -4783,7 +5298,7 @@ var fetchTokens9 = async ({
   }).map(
     (asset) => ({
       id: subHydrationTokenId(networkId, asset.onChainId),
-      type: MODULE_TYPE9,
+      type: MODULE_TYPE10,
       platform: "polkadot",
       networkId,
       onChainId: asset.onChainId,
@@ -4801,7 +5316,7 @@ var fetchTokens9 = async ({
     return configToken || token.isSufficient;
   }).map((token) => {
     const configToken = configTokenByAssetId[token.onChainId];
-    return configToken ? assign8({}, token, configToken) : token;
+    return configToken ? assign9({}, token, configToken) : token;
   }).filter((t) => {
     const parsed = SubHydrationTokenSchema2.safeParse(t);
     return parsed.success;
@@ -4811,12 +5326,12 @@ var fetchTokens9 = async ({
 // src/modules/substrate-hydration/getMiniMetadata.ts
 import { MINIMETADATA_VERSION as MINIMETADATA_VERSION5 } from "@talismn/chaindata-provider";
 import { compactMetadata as compactMetadata4, encodeMetadata as encodeMetadata4, parseMetadataRpc as parseMetadataRpc14 } from "@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)
@@ -4863,18 +5378,18 @@ var getData4 = (metadataRpc) => {
 
 // src/modules/substrate-hydration/getTransferCallData.ts
 import { mergeUint8 as mergeUint84 } from "@polkadot-api/utils";
-import { isTokenOfType as isTokenOfType9 } from "@talismn/chaindata-provider";
+import { isTokenOfType as isTokenOfType10 } from "@talismn/chaindata-provider";
 import { parseMetadataRpc as parseMetadataRpc15 } from "@talismn/scale";
 import { Binary as Binary4 } from "polkadot-api";
-var getTransferCallData9 = ({
+var getTransferCallData10 = ({
   from: from2,
   to,
   value,
   token,
   metadataRpc
 }) => {
-  if (!isTokenOfType9(token, MODULE_TYPE9))
-    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE9}.`);
+  if (!isTokenOfType10(token, MODULE_TYPE10))
+    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE10}.`);
   const { builder } = parseMetadataRpc15(metadataRpc);
   const { codec, location } = builder.buildCall("Currencies", "transfer");
   const args = {
@@ -4890,22 +5405,22 @@ var getTransferCallData9 = ({
 };
 
 // src/modules/substrate-hydration/subscribeBalances.ts
-import { isEqual as isEqual8 } from "lodash-es";
-import { distinctUntilChanged as distinctUntilChanged8, Observable as Observable8, of as of10 } from "rxjs";
-var SUBSCRIPTION_INTERVAL7 = 6e3;
-var subscribeBalances9 = ({
+import { isEqual as isEqual9 } from "lodash-es";
+import { distinctUntilChanged as distinctUntilChanged9, Observable as Observable9, of as of11 } from "rxjs";
+var SUBSCRIPTION_INTERVAL8 = 6e3;
+var subscribeBalances10 = ({
   networkId,
   tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
-  if (!tokensWithAddresses.length) return of10({ success: [], errors: [] });
-  return new Observable8((subscriber) => {
+  if (!tokensWithAddresses.length) return of11({ success: [], errors: [] });
+  return new Observable9((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,
@@ -4913,10 +5428,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,
@@ -4929,36 +5444,36 @@ var subscribeBalances9 = ({
     return () => {
       abortController.abort();
     };
-  }).pipe(distinctUntilChanged8(isEqual8));
+  }).pipe(distinctUntilChanged9(isEqual9));
 };
 
 // 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
 import { SubHydrationTokenSchema as SubHydrationTokenSchema3 } from "@talismn/chaindata-provider";
-import z12 from "zod/v4";
-var SubHydrationTokenConfigSchema = z12.strictObject({
+import z14 from "zod/v4";
+var SubHydrationTokenConfigSchema = z14.strictObject({
   onChainId: SubHydrationTokenSchema3.shape.onChainId,
   ...TokenConfigBaseSchema.shape
 });
 
 // src/modules/substrate-native/config.ts
 import { SubNativeTokenSchema } from "@talismn/chaindata-provider";
-var MODULE_TYPE10 = SubNativeTokenSchema.shape.type.value;
-var PLATFORM10 = SubNativeTokenSchema.shape.platform.value;
+var MODULE_TYPE11 = SubNativeTokenSchema.shape.type.value;
+var PLATFORM11 = SubNativeTokenSchema.shape.platform.value;
 
 // src/modules/substrate-native/queries/buildBaseQueries.ts
 import { decodeScale as decodeScale4 } from "@talismn/scale";
-import { isNotNil as isNotNil7 } from "@talismn/util";
+import { isNotNil as isNotNil8 } from "@talismn/util";
 
 // src/modules/substrate-native/util/lockTypes.ts
 import upperFirst from "lodash-es/upperFirst";
@@ -5119,7 +5634,7 @@ var buildBaseQueries = (networkId, balanceDefs, miniMetadata) => {
         return { balance, nomPoolMemberInfo };
       }
     };
-  }).filter(isNotNil7);
+  }).filter(isNotNil8);
 };
 var decodeBaseResult = (coder, value, networkId) => {
   const decoded = decodeScale4(
@@ -5359,11 +5874,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) => ({
@@ -5373,20 +5888,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: [],
@@ -5409,9 +5924,9 @@ import {
   SubNativeTokenSchema as SubNativeTokenSchema2,
   subNativeTokenId as subNativeTokenId2
 } from "@talismn/chaindata-provider";
-import { assign as assign9 } from "lodash-es";
-import z13 from "zod/v4";
-var fetchTokens10 = async ({ networkId, tokens, connector, miniMetadata }) => {
+import { assign as assign10 } from "lodash-es";
+import z15 from "zod/v4";
+var fetchTokens11 = async ({ networkId, tokens, connector, miniMetadata }) => {
   if (miniMetadata.extra.disable) return [];
   const { tokenSymbol: symbol, tokenDecimals: decimals } = await getChainProperties(
     connector,
@@ -5431,22 +5946,22 @@ var fetchTokens10 = async ({ networkId, tokens, connector, miniMetadata }) => {
     decimals,
     existentialDeposit: miniMetadata.extra.existentialDeposit ?? "0"
   };
-  const token = assign9(nativeToken, tokenConfig);
+  const token = assign10(nativeToken, tokenConfig);
   const parsed = SubNativeTokenSchema2.safeParse(token);
   if (!parsed.success) {
     return [];
   }
   return [parsed.data];
 };
-var DotNetworkPropertiesSimple = z13.object({
-  tokenDecimals: z13.number().optional().default(0),
-  tokenSymbol: z13.string().optional().default("Unit")
+var DotNetworkPropertiesSimple = z15.object({
+  tokenDecimals: z15.number().optional().default(0),
+  tokenSymbol: z15.string().optional().default("Unit")
 });
-var DotNetworkPropertiesArray = z13.object({
-  tokenDecimals: z13.array(z13.number()).nonempty(),
-  tokenSymbol: z13.array(z13.string()).nonempty()
+var DotNetworkPropertiesArray = z15.object({
+  tokenDecimals: z15.array(z15.number()).nonempty(),
+  tokenSymbol: z15.array(z15.string()).nonempty()
 });
-var DotNetworkPropertiesSchema = z13.union([DotNetworkPropertiesSimple, DotNetworkPropertiesArray]).transform((val) => ({
+var DotNetworkPropertiesSchema = z15.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
 }));
@@ -5458,8 +5973,8 @@ var getChainProperties = async (connector, networkId) => {
 // src/modules/substrate-native/getMiniMetadata.ts
 import { MINIMETADATA_VERSION as MINIMETADATA_VERSION6 } from "@talismn/chaindata-provider";
 import { compactMetadata as compactMetadata5, encodeMetadata as encodeMetadata5, parseMetadataRpc as parseMetadataRpc16 } from "@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)
@@ -5519,12 +6034,12 @@ var getMiniMetadata10 = ({ networkId, specVersion, metadataRpc, config }) => {
 
 // src/modules/substrate-native/getTransferCallData.ts
 import { mergeUint8 as mergeUint86 } from "@polkadot-api/utils";
-import { isTokenOfType as isTokenOfType10 } from "@talismn/chaindata-provider";
+import { isTokenOfType as isTokenOfType11 } from "@talismn/chaindata-provider";
 import {
   parseMetadataRpc as parseMetadataRpc17
 } from "@talismn/scale";
 import { Binary as Binary5, Enum as Enum3 } from "polkadot-api";
-var getTransferCallData10 = ({
+var getTransferCallData11 = ({
   from: from2,
   to,
   value,
@@ -5532,8 +6047,8 @@ var getTransferCallData10 = ({
   type,
   metadataRpc
 }) => {
-  if (!isTokenOfType10(token, MODULE_TYPE10))
-    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE10}.`);
+  if (!isTokenOfType11(token, MODULE_TYPE11))
+    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE11}.`);
   const { unifiedMetadata, lookupFn, builder } = parseMetadataRpc17(metadataRpc);
   const method = getTransferMethod3(type, unifiedMetadata, lookupFn);
   const { codec, location } = builder.buildCall("Balances", method);
@@ -5611,9 +6126,9 @@ var getTransferAllEncodedArgs3 = (to, codec) => {
 };
 
 // src/modules/substrate-native/subscribeBalances.ts
-import { map as map4, of as of11, switchMap } from "rxjs";
-var subscribeBalances10 = ({ networkId, tokensWithAddresses, connector, miniMetadata }) => {
-  if (!tokensWithAddresses.length) return of11({ success: [], errors: [] });
+import { map as map4, of as of12, switchMap } from "rxjs";
+var subscribeBalances11 = ({ networkId, tokensWithAddresses, connector, miniMetadata }) => {
+  if (!tokensWithAddresses.length) return of12({ success: [], errors: [] });
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   const baseQueries = buildBaseQueries(networkId, balanceDefs, miniMetadata);
   return getRpcQueryPack$(connector, networkId, baseQueries).pipe(
@@ -5630,34 +6145,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
-import z14 from "zod/v4";
-var SubNativeTokenConfigSchema = z14.strictObject({
+import z16 from "zod/v4";
+var SubNativeTokenConfigSchema = z16.strictObject({
   ...TokenConfigBaseSchema.shape
 });
-var SubNativeModuleConfigSchema = z14.strictObject({
-  disable: z14.boolean().optional()
+var SubNativeModuleConfigSchema = z16.strictObject({
+  disable: z16.boolean().optional()
 });
-var SubNativeMiniMetadataExtraSchema = z14.strictObject({
-  disable: z14.boolean().optional(),
-  useLegacyTransferableCalculation: z14.boolean().optional(),
-  existentialDeposit: z14.string().optional(),
-  nominationPoolsPalletId: z14.string().optional()
+var SubNativeMiniMetadataExtraSchema = z16.strictObject({
+  disable: z16.boolean().optional(),
+  useLegacyTransferableCalculation: z16.boolean().optional(),
+  existentialDeposit: z16.string().optional(),
+  nominationPoolsPalletId: z16.string().optional()
 });
 
 // src/modules/substrate-psp22/config.ts
 import { SubPsp22TokenSchema } from "@talismn/chaindata-provider";
-var MODULE_TYPE11 = SubPsp22TokenSchema.shape.type.value;
-var PLATFORM11 = SubPsp22TokenSchema.shape.platform.value;
+var MODULE_TYPE12 = SubPsp22TokenSchema.shape.type.value;
+var PLATFORM12 = SubPsp22TokenSchema.shape.platform.value;
 
 // src/modules/substrate-psp22/fetchBalances.ts
 import { Abi } from "@polkadot/api-contract";
@@ -6661,7 +7176,17 @@ var psp22_default = {
 };
 
 // src/modules/substrate-psp22/util.ts
-import { u8aConcatStrict, u8aToHex } from "@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,
@@ -6690,7 +7215,7 @@ var makeContractCaller = ({
 );
 
 // src/modules/substrate-psp22/fetchBalances.ts
-var fetchBalances11 = async ({
+var fetchBalances12 = async ({
   networkId,
   tokensWithAddresses,
   connector
@@ -6745,13 +7270,14 @@ var fetchBalances11 = async ({
 // src/modules/substrate-psp22/fetchTokens.ts
 import { Abi as Abi2 } from "@polkadot/api-contract";
 import { TypeRegistry as TypeRegistry2 } from "@polkadot/types";
-import { hexToNumber, u8aToString } from "@polkadot/util";
 import {
   SubPsp22TokenSchema as SubPsp22TokenSchema2,
   subPsp22TokenId
 } from "@talismn/chaindata-provider";
 import { values } from "lodash-es";
-var fetchTokens11 = async ({
+var hexToNumber = (hex) => Number(hex);
+var u8aToString = (value) => new TextDecoder().decode(value);
+var fetchTokens12 = async ({
   networkId,
   tokens,
   connector
@@ -6827,12 +7353,12 @@ var fetchTokens11 = async ({
 // src/modules/substrate-psp22/getMiniMetadata.ts
 import { MINIMETADATA_VERSION as MINIMETADATA_VERSION7 } from "@talismn/chaindata-provider";
 import { parseMetadataRpc as parseMetadataRpc18 } from "@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)
@@ -6860,12 +7386,12 @@ var getMiniMetadata11 = ({
 import { Abi as Abi3 } from "@polkadot/api-contract";
 import { TypeRegistry as TypeRegistry3 } from "@polkadot/types";
 import { mergeUint8 as mergeUint87 } from "@polkadot-api/utils";
-import { isTokenOfType as isTokenOfType11, parseTokenId as parseTokenId5 } from "@talismn/chaindata-provider";
+import { isTokenOfType as isTokenOfType12, parseTokenId as parseTokenId5 } from "@talismn/chaindata-provider";
 import { parseMetadataRpc as parseMetadataRpc19 } from "@talismn/scale";
 import { Binary as Binary6, Enum as Enum4 } from "polkadot-api";
-var getTransferCallData11 = async ({ from: from2, to, value, token, metadataRpc, connector }) => {
-  if (!isTokenOfType11(token, MODULE_TYPE11))
-    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE11}.`);
+var getTransferCallData12 = async ({ from: from2, to, value, token, metadataRpc, connector }) => {
+  if (!isTokenOfType12(token, MODULE_TYPE12))
+    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE12}.`);
   const networkId = parseTokenId5(token.id).networkId;
   const { builder } = parseMetadataRpc19(metadataRpc);
   const { codec, location } = builder.buildCall("Contracts", "call");
@@ -6897,22 +7423,22 @@ var getTransferCallData11 = async ({ from: from2, to, value, token, metadataRpc,
 };
 
 // src/modules/substrate-psp22/subscribeBalances.ts
-import { isEqual as isEqual9 } from "lodash-es";
-import { distinctUntilChanged as distinctUntilChanged9, Observable as Observable9, of as of12 } from "rxjs";
-var SUBSCRIPTION_INTERVAL8 = 6e3;
-var subscribeBalances11 = ({
+import { isEqual as isEqual10 } from "lodash-es";
+import { distinctUntilChanged as distinctUntilChanged10, Observable as Observable10, of as of13 } from "rxjs";
+var SUBSCRIPTION_INTERVAL9 = 6e3;
+var subscribeBalances12 = ({
   networkId,
   tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
-  if (!tokensWithAddresses.length) return of12({ success: [], errors: [] });
-  return new Observable9((subscriber) => {
+  if (!tokensWithAddresses.length) return of13({ success: [], errors: [] });
+  return new Observable10((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,
@@ -6920,10 +7446,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,
@@ -6936,36 +7462,36 @@ var subscribeBalances11 = ({
     return () => {
       abortController.abort();
     };
-  }).pipe(distinctUntilChanged9(isEqual9));
+  }).pipe(distinctUntilChanged10(isEqual10));
 };
 
 // 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
 import { SubPsp22TokenSchema as SubPsp22TokenSchema3 } from "@talismn/chaindata-provider";
-import z15 from "zod/v4";
-var SubPsp22TokenConfigSchema = z15.strictObject({
+import z17 from "zod/v4";
+var SubPsp22TokenConfigSchema = z17.strictObject({
   contractAddress: SubPsp22TokenSchema3.shape.contractAddress,
   ...TokenConfigBaseSchema.shape
 });
 
 // src/modules/substrate-tokens/config.ts
 import { SubTokensTokenSchema } from "@talismn/chaindata-provider";
-var MODULE_TYPE12 = SubTokensTokenSchema.shape.type.value;
-var PLATFORM12 = SubTokensTokenSchema.shape.platform.value;
+var MODULE_TYPE13 = SubTokensTokenSchema.shape.type.value;
+var PLATFORM13 = SubTokensTokenSchema.shape.platform.value;
 
 // src/modules/substrate-tokens/buildQueries.ts
 import { decodeScale as decodeScale6, papiParse as papiParse3 } from "@talismn/scale";
-import { isNotNil as isNotNil8 } from "@talismn/util";
+import { isNotNil as isNotNil9 } from "@talismn/util";
 var buildQueries3 = (networkId, balanceDefs, miniMetadata) => {
   const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
     storage: [miniMetadata.extra.palletId, "Accounts"]
@@ -7013,15 +7539,15 @@ var buildQueries3 = (networkId, balanceDefs, miniMetadata) => {
       stateKeys: [stateKey],
       decodeResult
     };
-  }).filter(isNotNil8);
+  }).filter(isNotNil9);
 };
 
 // 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) => ({
@@ -7031,20 +7557,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: [],
@@ -7068,7 +7594,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" },
@@ -7083,19 +7609,19 @@ var fetchBalances12 = async ({ networkId, tokensWithAddresses, connector, miniMe
 
 // src/modules/substrate-tokens/fetchTokens.ts
 import { subTokensTokenId } from "@talismn/chaindata-provider";
-import { assign as assign10 } from "lodash-es";
-var fetchTokens12 = async ({
+import { assign as assign11 } from "lodash-es";
+var fetchTokens13 = async ({
   networkId,
   tokens,
   miniMetadata
 }) => {
   if (!miniMetadata?.data) return [];
   return tokens.map(
-    (tokenConfig) => assign10(
+    (tokenConfig) => assign11(
       {
         id: subTokensTokenId(networkId, tokenConfig.onChainId),
-        type: MODULE_TYPE12,
-        platform: PLATFORM12,
+        type: MODULE_TYPE13,
+        platform: PLATFORM13,
         networkId,
         onChainId: tokenConfig.onChainId,
         symbol: tokenConfig.symbol ?? "Unit",
@@ -7112,8 +7638,8 @@ var fetchTokens12 = async ({
 // src/modules/substrate-tokens/getMiniMetadata.ts
 import { MINIMETADATA_VERSION as MINIMETADATA_VERSION8 } from "@talismn/chaindata-provider";
 import { compactMetadata as compactMetadata6, encodeMetadata as encodeMetadata6, parseMetadataRpc as parseMetadataRpc20 } from "@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)
@@ -7146,12 +7672,12 @@ var getData5 = (metadataRpc, pallet) => {
 
 // src/modules/substrate-tokens/getTransferCallData.ts
 import { mergeUint8 as mergeUint88 } from "@polkadot-api/utils";
-import { isTokenOfType as isTokenOfType12 } from "@talismn/chaindata-provider";
+import { isTokenOfType as isTokenOfType13 } from "@talismn/chaindata-provider";
 import { papiParse as papiParse4, parseMetadataRpc as parseMetadataRpc21 } from "@talismn/scale";
 import { Binary as Binary7, Enum as Enum5 } from "polkadot-api";
-var getTransferCallData12 = ({ from: from2, to, value, token, type, metadataRpc, config }) => {
-  if (!isTokenOfType12(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 (!isTokenOfType13(token, MODULE_TYPE13))
+    throw new Error(`Token type ${token.type} is not ${MODULE_TYPE13}.`);
   const { builder } = parseMetadataRpc21(metadataRpc);
   const options = getCallDataOptions(to, token, value, type, config);
   const callData = getCallDataFromOptions(builder, options);
@@ -7264,9 +7790,9 @@ var getCallDataOptions = (to, token, value, type, config) => {
 };
 
 // src/modules/substrate-tokens/subscribeBalances.ts
-import { map as map5, of as of13 } from "rxjs";
-var subscribeBalances12 = ({ networkId, tokensWithAddresses, connector, miniMetadata }) => {
-  if (!tokensWithAddresses.length) return of13({ success: [], errors: [] });
+import { map as map5, of as of14 } from "rxjs";
+var subscribeBalances13 = ({ networkId, tokensWithAddresses, connector, miniMetadata }) => {
+  if (!tokensWithAddresses.length) return of14({ success: [], errors: [] });
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   const queries = buildQueries3(networkId, balanceDefs, miniMetadata);
   return getRpcQueryPack$(connector, networkId, queries).pipe(
@@ -7279,31 +7805,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
 import { SubTokensTokenSchema as SubTokensTokenSchema2 } from "@talismn/chaindata-provider";
-import z16 from "zod/v4";
-var SubTokensTokenConfigSchema = z16.strictObject({
+import z18 from "zod/v4";
+var SubTokensTokenConfigSchema = z18.strictObject({
   onChainId: SubTokensTokenSchema2.shape.onChainId,
   ...TokenConfigBaseSchema.shape,
   // force these 3 fields because in this module we wont pull anything from chain
-  symbol: z16.string().nonempty(),
-  decimals: z16.number(),
-  existentialDeposit: z16.string().nonempty()
+  symbol: z18.string().nonempty(),
+  decimals: z18.number(),
+  existentialDeposit: z18.string().nonempty()
 });
-var SubTokensModuleConfigSchema = z16.strictObject({
-  palletId: z16.string().optional()
+var SubTokensModuleConfigSchema = z18.strictObject({
+  palletId: z18.string().optional()
 });
-var SubTokensMiniMetadataExtraSchema = z16.strictObject({
-  palletId: z16.string()
+var SubTokensMiniMetadataExtraSchema = z18.strictObject({
+  palletId: z18.string()
 });
 
 // src/modules/index.ts
@@ -7319,7 +7845,8 @@ var BALANCE_MODULES = [
   EvmUniswapV2BalanceModule,
   EvmNativeBalanceModule,
   SolNativeBalanceModule,
-  SolSplBalanceModule
+  SolSplBalanceModule,
+  SolToken2022BalanceModule
 ];
 
 // src/getMiniMetadatas/getMetadataRpc.ts
@@ -7427,16 +7954,16 @@ var BalancesProvider = class {
     this.#chaindataProvider = chaindataProvider;
     this.#chainConnectors = chainConnectors;
     this.#storage = new BehaviorSubject2({
-      balances: keyBy8(storage.balances.filter(isNotNil9), (b) => getBalanceId(b)),
-      miniMetadatas: keyBy8(storage.miniMetadatas.filter(isNotNil9), (m) => m.id)
+      balances: keyBy9(storage.balances.filter(isNotNil10), (b) => getBalanceId(b)),
+      miniMetadatas: keyBy9(storage.miniMetadatas.filter(isNotNil10), (m) => m.id)
     });
   }
   get storage$() {
     return this.#storage.pipe(
       map6(
         ({ balances, miniMetadatas }) => ({
-          balances: values2(balances).filter(isNotNil9).sort(sortByBalanceId),
-          miniMetadatas: values2(miniMetadatas).filter(isNotNil9).sort(sortByMiniMetadataId)
+          balances: values2(balances).filter(isNotNil10).sort(sortByBalanceId),
+          miniMetadatas: values2(miniMetadatas).filter(isNotNil10).sort(sortByMiniMetadataId)
         }),
         shareReplay(1)
       )
@@ -7444,8 +7971,8 @@ var BalancesProvider = class {
   }
   get storedMiniMetadataMapById$() {
     return this.#storage.pipe(
-      map6((storage) => keyBy8(storage.miniMetadatas, (m) => m.id)),
-      distinctUntilChanged10(isEqual10),
+      map6((storage) => keyBy9(storage.miniMetadatas, (m) => m.id)),
+      distinctUntilChanged11(isEqual11),
       shareReplay(1)
     );
   }
@@ -7465,7 +7992,7 @@ var BalancesProvider = class {
         )
       ),
       switchMap2((addressesByTokenIdByNetworkId) => {
-        if (!keys3(addressesByTokenIdByNetworkId).length) return of14({ isStale: false, results: [] });
+        if (!keys3(addressesByTokenIdByNetworkId).length) return of15({ isStale: false, results: [] });
         return combineLatest({
           isStale: timer(3e4).pipe(
             map6(() => true),
@@ -7490,7 +8017,7 @@ var BalancesProvider = class {
           failedBalanceIds: results.flatMap((result) => result.failedBalanceIds)
         })
       ),
-      distinctUntilChanged10(isEqual10)
+      distinctUntilChanged11(isEqual11)
     );
   }
   fetchBalances(addressesByTokenId) {
@@ -7529,7 +8056,7 @@ var BalancesProvider = class {
               }
               default: {
                 log_default.warn("[balances] Unsupported network platform for module", { networkId, mod });
-                return of14({ status: "live", balances: [], failedBalanceIds: [] });
+                return of15({ status: "live", balances: [], failedBalanceIds: [] });
               }
             }
           })
@@ -7537,14 +8064,14 @@ var BalancesProvider = class {
       }),
       map6((results) => {
         const errorBalanceIds = results.flatMap((result) => result.failedBalanceIds);
-        const staleBalances = errorBalanceIds.map((balanceId) => this.#storage.value.balances[balanceId]).filter(isNotNil9).map((b) => ({ ...b, status: "stale" }));
+        const staleBalances = errorBalanceIds.map((balanceId) => this.#storage.value.balances[balanceId]).filter(isNotNil10).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: []
         };
       }),
-      distinctUntilChanged10(isEqual10)
+      distinctUntilChanged11(isEqual11)
     );
   }
   getPolkadotNetworkModuleBalances$(networkId, tokensWithAddresses, mod) {
@@ -7553,7 +8080,7 @@ var BalancesProvider = class {
       { networkId, mod, tokensWithAddresses },
       () => {
         if (!tokensWithAddresses.length)
-          return of14({ status: "live", balances: [], failedBalanceIds: [] });
+          return of15({ status: "live", balances: [], failedBalanceIds: [] });
         const moduleAddressesByTokenId = fromPairs2(
           tokensWithAddresses.map(([token, addresses]) => [token.id, addresses])
         );
@@ -7563,7 +8090,7 @@ var BalancesProvider = class {
         if (!this.#chainConnectors.substrate) {
           log_default.warn("[balances] no substrate connector or miniMetadata for module", mod.type);
           return defer(
-            () => of14({
+            () => of15({
               status: "initialising",
               balances: this.getStoredBalances(moduleAddressesByTokenId),
               failedBalanceIds: []
@@ -7622,7 +8149,7 @@ var BalancesProvider = class {
       { networkId, mod, tokensWithAddresses },
       () => {
         if (!tokensWithAddresses.length)
-          return of14({ status: "live", balances: [], failedBalanceIds: [] });
+          return of15({ status: "live", balances: [], failedBalanceIds: [] });
         const moduleAddressesByTokenId = fromPairs2(
           tokensWithAddresses.map(([token, addresses]) => [token.id, addresses])
         );
@@ -7632,7 +8159,7 @@ var BalancesProvider = class {
         if (!this.#chainConnectors.evm) {
           log_default.warn("[balances] no ethereum connector for module", mod.type);
           return defer(
-            () => of14({
+            () => of15({
               status: "initialising",
               balances: this.getStoredBalances(moduleAddressesByTokenId),
               failedBalanceIds: []
@@ -7681,7 +8208,7 @@ var BalancesProvider = class {
       { networkId, mod, tokensWithAddresses },
       () => {
         if (!tokensWithAddresses.length)
-          return of14({ status: "live", balances: [], failedBalanceIds: [] });
+          return of15({ status: "live", balances: [], failedBalanceIds: [] });
         const moduleAddressesByTokenId = fromPairs2(
           tokensWithAddresses.map(([token, addresses]) => [token.id, addresses])
         );
@@ -7691,7 +8218,7 @@ var BalancesProvider = class {
         if (!this.#chainConnectors.solana) {
           log_default.warn("[balances] no solana connector for module", mod.type);
           return defer(
-            () => of14({
+            () => of15({
               status: "initialising",
               balances: this.getStoredBalances(moduleAddressesByTokenId),
               failedBalanceIds: []
@@ -7705,6 +8232,11 @@ var BalancesProvider = class {
         }).pipe(
           catchError(() => EMPTY),
           // don't emit, let provider mark balances stale
+          tap((results) => {
+            if (results.dynamicTokens?.length) {
+              this.#chaindataProvider.registerDynamicTokens(results.dynamicTokens);
+            }
+          }),
           map6(
             (results) => ({
               status: "live",
@@ -7738,14 +8270,14 @@ var BalancesProvider = class {
     if (balancesResult.status !== "live") return;
     const storage = this.#storage.getValue();
     const failedIds = new Set(balancesResult.failedBalanceIds);
-    const balances = assign11(
+    const balances = assign12(
       {},
       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.
       fromPairs2(
         balanceIds.filter((bid) => !failedIds.has(bid)).map((balanceId) => [balanceId, void 0])
       ),
-      keyBy8(
+      keyBy9(
         // 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)
@@ -7755,7 +8287,7 @@ var BalancesProvider = class {
       const balance = balances[errorBalanceId];
       if (balance) balance.status = "stale";
     }
-    this.#storage.next(assign11({}, storage, { balances }));
+    this.#storage.next(assign12({}, storage, { balances }));
   }
   getNetworkMiniMetadatas$(networkId) {
     return getSharedObservable(`BalancesProvider.getNetworkMiniMetadatas$`, { networkId }, () => {
@@ -7763,11 +8295,11 @@ var BalancesProvider = class {
         switchMap2(
           (network) => isNetworkDot(network) ? this.getNetworkSpecVersion$(networkId).pipe(
             switchMap2(
-              (specVersion) => specVersion === null ? of14([]) : this.getMiniMetadatas$(networkId, specVersion)
+              (specVersion) => specVersion === null ? of15([]) : this.getMiniMetadatas$(networkId, specVersion)
             )
-          ) : of14([])
+          ) : of15([])
         ),
-        distinctUntilChanged10(isEqual10)
+        distinctUntilChanged11(isEqual11)
       );
     });
   }
@@ -7783,7 +8315,7 @@ var BalancesProvider = class {
     ).pipe(
       catchError(() => {
         log_default.warn("Failed to fetch spec version for network", networkId);
-        return of14(null);
+        return of15(null);
       })
     );
   }
@@ -7800,9 +8332,9 @@ var BalancesProvider = class {
       storedMiniMetadatas: this.getStoredMiniMetadatas$(miniMetadataIds)
     }).pipe(
       switchMap2(({ storedMiniMetadatas, defaultMiniMetadatas }) => {
-        if (defaultMiniMetadatas) return of14(defaultMiniMetadatas);
-        if (storedMiniMetadatas) return of14(storedMiniMetadatas);
-        if (!this.#chainConnectors.substrate) return of14([]);
+        if (defaultMiniMetadatas) return of15(defaultMiniMetadatas);
+        if (storedMiniMetadatas) return of15(storedMiniMetadatas);
+        if (!this.#chainConnectors.substrate) return of15([]);
         return from(
           withRetry(
             () => (
@@ -7825,27 +8357,27 @@ var BalancesProvider = class {
         ).pipe(
           catchError(() => {
             log_default.warn("Failed to fetch metadata for network", networkId);
-            return of14([]);
+            return of15([]);
           }),
           // and persist in storage for later reuse
           tap((newMiniMetadatas) => {
             if (!newMiniMetadatas.length) return;
             const storage = this.#storage.getValue();
-            const miniMetadatas = assign11(
+            const miniMetadatas = assign12(
               // keep minimetadatas of other networks
-              keyBy8(
+              keyBy9(
                 values2(storage.miniMetadatas).filter((m) => m.chainId !== networkId),
                 (m) => m.id
               ),
               // add the ones for our network
-              keyBy8(newMiniMetadatas, (m) => m.id)
+              keyBy9(newMiniMetadatas, (m) => m.id)
             );
-            this.#storage.next(assign11({}, storage, { miniMetadatas }));
+            this.#storage.next(assign12({}, storage, { miniMetadatas }));
           })
         );
       }),
       // emit only when mini metadata changes, as a change here would restart all subscriptions for the network
-      distinctUntilChanged10(isEqual10)
+      distinctUntilChanged11(isEqual11)
     );
   }
   getStoredMiniMetadatas$(miniMetadataIds) {
@@ -7855,7 +8387,7 @@ var BalancesProvider = class {
         return miniMetadatas.length && miniMetadatas.every(isTruthy) ? miniMetadatas : null;
       }),
       // source changes very often
-      distinctUntilChanged10(isEqual10)
+      distinctUntilChanged11(isEqual11)
     );
   }
   getDefaultMiniMetadatas$(miniMetadataIds) {
@@ -7870,7 +8402,7 @@ var BalancesProvider = class {
     const balanceDefs = toPairs2(addressesByToken).flatMap(
       ([tokenId, addresses]) => addresses.map((address) => [tokenId, address])
     );
-    return balanceDefs.map(([tokenId, address]) => this.#storage.value.balances[getBalanceId({ address, tokenId })]).filter(isNotNil9).sort(sortByBalanceId);
+    return balanceDefs.map(([tokenId, address]) => this.#storage.value.balances[getBalanceId({ address, tokenId })]).filter(isNotNil10).sort(sortByBalanceId);
   }
   cleanupAddressesByTokenId$(addressesByTokenId) {
     return this.#chaindataProvider.getNetworksMapById$().pipe(
@@ -7881,7 +8413,7 @@ var BalancesProvider = class {
             const network = networksById[networkId];
             return [
               tokenId,
-              uniq5(addresses.map(normalizeAddress)).filter(
+              uniq6(addresses.map(normalizeAddress)).filter(
                 (address) => network && isAddressCompatibleWithNetwork(network, address)
               )
             ];
@@ -7943,6 +8475,8 @@ export {
   SolNativeTokenConfigSchema,
   SolSplBalanceModule,
   SolSplTokenConfigSchema,
+  SolToken2022BalanceModule,
+  SolToken2022TokenConfigSchema,
   SubAssetsBalanceModule,
   SubAssetsTokenConfigSchema,
   SubDTaoBalanceModule,