solana-risk-engine 0.4.11 → 0.4.13

package/README.md

@@ -28,7 +28,7 @@ for (const l of r.lights)  // the four traffic lights
 | **Real concentration** | Largest accounts are traced to their owners. Pools and programs are separated from people, so `w1`/`w10` measure *people*, not AMM vaults. |
 | **Inflated liquidity** | DexScreener values both sides of a pool at the pool's price. A pool with 4B of a token against 2 USDC shows "$4,000M liquidity". The engine recomputes it from the real side (USDC/USDT/SOL). It only flags extreme gaps (real side under 5%), because concentrated-liquidity pools are lopsided by nature. |
 | **Unlocked LP** | % of LP locked/burned via RugCheck. It only counts for markets under 90 days old, so veteran tokens don't get false positives, and never while a token is on Pump.fun's bonding curve, where there is no LP to pull. |
-| **Serial creators** | For markets under 7 days: how many other tokens the creator launched in the last 24 h (RugCheck). 2 or more is a warning, 5 or more a red flag. `recentLaunches(client, wallet)` counts the same on chain for the wallet that *paid* a launch, which catches farms that name a fresh creator each time. |
+| **Serial creators** | For markets under 7 days: how many other tokens the creator launched in the last 24 h (RugCheck). 2 or more is a warning, 5 or more a red flag. `recentLaunches(client, wallet)` counts the same on chain for the wallet that *paid* a launch, which catches farms that name a fresh creator each time. When RugCheck has no report yet (it often answers 400 for tokens a few minutes old) the analysis falls back to `chainLaunches(client, mint)`: that count for the first signer of the token's creation transaction, reported as its own signal `CTL_SERIAL_PAYER` ("the wallet that paid for this launch…", never as the creator) and skipped when the SolFlag wallet base knows that wallet as an exchange or platform. |
 | **Impostors** | Tokens using the symbol or name of a famous token (USDC, JUP, BONK, WIF, BTC, ETH...) with a different address. |
 | **Real brands** | About 320 real companies with no token on Solana (Spotify, Nike, Zara, Ferrari...). A token called just that is a red flag and **HIGH**; the brand as one word of a longer name is a warning. Everyday words that are also brands (Shell, Target, Puma) are left out, and markets at least 30 days old with $100k+ liquidity are not checked. |
 | **Known issuers and official tokens** | Stablecoins from Paxos (PYUSD, USDG), Circle (USDC, EURC) and Tether (USDT), tokenized shares from xStocks (all recognised by their control keys, taken from mints the issuer lists on its own pages) and official tokens from exchanges and Socios.com (bnSOL, bbSOL, cbBTC, club fan tokens..., by mint address) are shown as dependency on the issuer. Their large holders (treasury, custodians, exchanges) are shown but do not count as concentration, a 0% transfer fee is not a warning, and a tiny Solana pool is a warning, not a red flag. A short **trusted** list (Circle, Paxos, Tether, xStocks; `trustedIssuer()`) goes further: every light green, holders not checked. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solana-risk-engine",
-  "version": "0.4.11",
+  "version": "0.4.13",
   "description": "Explainable risk analysis for Solana tokens and wallets: creator control, real holder concentration, inflated liquidity, impostor tokens, funder clusters and PnL. Zero dependencies, runs in Node and the browser.",
   "type": "module",
   "main": "./src/index.js",

package/src/i18n/en.js

@@ -38,6 +38,7 @@ export default {
     CTL_KNOWN_ISSUER: (d) => "Controlled by its issuer, " + d.issuer + " (see dependency)",
     CTL_NONE: () => "No active authorities: nobody can mint more or freeze",
     CTL_SERIAL_CREATOR: (d) => "The creator launched " + d.n + " other tokens in the last 24 h (per RugCheck): a serial launcher, who usually drops each token as soon as buyers arrive",
+    CTL_SERIAL_PAYER: (d) => "The wallet that paid for this launch launched " + d.n + " other tokens in the last 24 h (counted on chain): a serial launcher, who usually drops each token as soon as buyers arrive",
     BRAND_COPY: (d) => "Uses the name of " + d.brand + ", a real company with no token on Solana: it is not official, almost certainly an imitation to draw buyers",
     BRAND_NAME: (d) => "Uses the name of " + d.brand + ", a real company: it is not an official " + d.brand + " token",
     COPYCAT: (d) => "There " + (d.n === 1 ? "is another token" : "are " + d.n + " more tokens") + " with the same name and ticker; the oldest one with a real market (" + short(d.original) + ", " + d.days + (d.days === 1 ? " day" : " days") + " old) is not this one: check you have the right address",

package/src/i18n/es.js

@@ -1,120 +1,121 @@
-// Spanish texts: the same wording the original single-file scanner used
-function usd(n) {
-  if (!n) return "0 $";
-  if (n < 0.01) return "<0,01 $";
-  // de-DE instead of es-ES: same format (dot thousands, comma decimals), but es-ES does not group
-  // 4-digit numbers and "6494 $" showed next to "22.505 $"
-  return n.toLocaleString("de-DE", { minimumFractionDigits: n < 1000 ? 2 : 0, maximumFractionDigits: n < 1000 ? 2 : 0 }) + " $";
-}
-function pct(n) { return Math.round(n) + "%"; }
-function short(a) { return a.slice(0, 4) + "…" + a.slice(-4); }
-function prog(d) { return d && d.prog >= 20 ? ". Los pools y programas guardan el " + pct(d.prog) : ""; }
-
-const EXT = {
-  permanentDelegate: "El emisor puede mover o quemar tus tokens (delegado permanente). Es normal en acciones tokenizadas, pero hay que confiar en el emisor",
-  transferHook: "Tiene transfer hook: ejecuta código externo en cada transferencia",
-  transferFeeConfig: "Cobra una comisión en cada transferencia",
-  nonTransferable: "No se puede transferir",
-  defaultAccountState: "Las cuentas nuevas pueden crearse congeladas"
-};
-
-export default {
-  fmt: { usd: usd, pct: pct, short: short },
-  signals: {
-    NO_INFO: () => "No se pudo leer la información del token",
-    MINT_BY_PROGRAM: () => "El mint lo controla un programa (suele ser un puente o un protocolo): hay que confiar en ese código",
-    MINT_ACTIVE: (d) => "El creador todavía puede crear más tokens (mint activo" + (d && d.byWallet ? ", en manos de una wallet" : "") + ")",
-    FREEZE_BY_PROGRAM: () => "El freeze lo controla un programa: puede congelar cuentas según su código",
-    FREEZE_ACTIVE: (d) => "El creador puede congelar cuentas (freeze activo" + (d && d.byWallet ? ", en manos de una wallet" : "") + ")",
-    EXTENSION: (d) => EXT[d.ext] || ("Extensión " + d.ext),
-    NO_MARKET: () => "No hay mercado en DexScreener (sin precio ni liquidez)",
-    MARKET_UNCHECKED: () => "No se pudo consultar el mercado de este token (fallo de red al conectar con DexScreener): vuelve a analizarlo para comprobarlo",
-    KNOWN_TOKEN: () => "Token muy conocido",
-
-    CTL_MINT_ACTIVE: () => "El creador puede crear más tokens (mint activo)",
-    CTL_FREEZE_ACTIVE: () => "El creador puede congelar cuentas (freeze activo)",
-    CTL_TRANSFER_HOOK: () => "Ejecuta código externo en cada transferencia",
-    CTL_TRANSFER_FEE: () => "Cobra una comisión en cada transferencia",
-    CTL_NON_TRANSFERABLE: () => "No se puede transferir",
-    CTL_DEFAULT_FROZEN: () => "Las cuentas nuevas pueden crearse congeladas",
-    CTL_ONLY_PROGRAMS: () => "Solo hay autoridades controladas por un programa (ver dependencia)",
-    CTL_KNOWN_ISSUER: (d) => "Lo controla su emisor, " + d.issuer + " (ver dependencia)",
-    CTL_NONE: () => "Sin autoridades activas: nadie puede crear más ni congelar",
-    CTL_SERIAL_CREATOR: (d) => "El creador ha lanzado " + d.n + " tokens más en las últimas 24 h (según RugCheck): es un lanzador en serie, que suele abandonar cada token en cuanto llegan compradores",
-    BRAND_COPY: (d) => "Usa el nombre de " + d.brand + ", una empresa real que no tiene token en Solana: no es oficial, casi seguro una imitación para atraer compradores",
-    BRAND_NAME: (d) => "Usa el nombre de " + d.brand + ", una empresa real: no es un token oficial de " + d.brand,
-    COPYCAT: (d) => "Hay " + (d.n === 1 ? "otro token" : d.n + " tokens más") + " con el mismo nombre y ticker; el más antiguo con mercado real (" + short(d.original) + ", de hace " + d.days + (d.days === 1 ? " día" : " días") + ") no es este: comprueba que tienes la dirección correcta",
-    HOLD_GROUP: (d) => d.n + " holders recibieron su primer SOL de la misma wallet y juntos tienen el " + pct(d.pct) + " del suministro: probablemente son la misma persona o equipo",
-    CTL_CREATOR_HISTORY: (d) => "De los " + d.old + " tokens que el creador lanzó antes (hace más de 24 h), " + d.dead + " se quedaron por debajo de 10.000 $ de capitalización (según RugCheck): sus lanzamientos no suelen despegar",
-    IMPOSTOR: (d) => "No es el " + d.symbol + " original. Comprueba que es el token que buscas",
-
-    CON_SKIPPED: () => "Sin comprobar la concentración de holders",
-    CON_UNAVAILABLE: () => "No se pudo comprobar la concentración de holders (el servicio no respondió; prueba otra vez en un rato)",
-    CON_ALL_POOLS: (d) => "Casi todo el supply está en pools o programas" + prog(d),
-    CON_OK: (d) => "Sin concentración preocupante (mayor wallet individual: " + pct(d.w1) + ")" + prog(d),
-    CON_TRUSTED: (d) => "No cuenta: en un token de " + d.issuer + " los grandes holders son su tesorería, custodios, exchanges y protocolos",
-    CON_ISSUER: (d) => "La mayor wallet tiene el " + pct(d.w1) + " y las 10 mayores el " + pct(d.w10) + ": con un emisor verificado suelen ser su tesorería, custodios, exchanges o protocolos, no cuenta como riesgo" + prog(d),
-    CON_HIGH: (d) => "La mayor wallet individual tiene el " + pct(d.w1) + " y las 10 mayores el " + pct(d.w10) + " del supply" + prog(d),
-    CON_UNSPLIT: (d) => "No se pudo separar pools de personas. La mayor cuenta tiene el " + pct(d.top1) + " del supply",
-
-    MKT_LIQ_INFLATED: (d) => "Liquidez inflada: DexScreener dice " + usd(d.reported) + ", pero el pool solo tiene unos " + usd(d.real) + " en tokens de verdad (USDC, USDT o SOL). Es lo máximo que podrías sacar al vender" + (d.reported >= 100 * Math.max(d.real, 1) ? ". Una diferencia así no es casual: está montada para que el token parezca establecido" : ""),
-    MKT_LIQ_VERY_LOW: (d) => "Liquidez muy baja (" + usd(d.liq) + ")",
-    MKT_LIQ_LOW: (d) => "Liquidez baja (" + usd(d.liq) + ")",
-    MKT_VOLUME_LOW: (d) => "Volumen de 24 h casi nulo (" + usd(d.vol) + ")",
-    MKT_NEW: (d) => "Mercado muy nuevo (" + (d.days < 1 ? "menos de un día" : d.days + (d.days === 1 ? " día" : " días")) + ")",
-    MKT_POSITION_HEAVY: (d) => "La posición de esta wallet equivale al " + pct(d.pct) + " de la liquidez: vender de golpe movería mucho el precio",
-    MKT_LP_UNLOCKED: (d) => "Solo el " + pct(d.pct) + " de la liquidez está bloqueada o quemada (según RugCheck): el resto se puede retirar de golpe",
-    MKT_LP_PARTLY_LOCKED: (d) => "Solo el " + pct(d.pct) + " de la liquidez está bloqueada o quemada (según RugCheck)",
-    MKT_OK: (d) => "Liquidez " + usd(d.liq) + " · volumen 24 h " + usd(d.vol),
-
-    DEP_PROGRAM_AUTHORITY: () => "Un programa controla el mint o el freeze (puente o protocolo): hay que confiar en su código",
-    DEP_PERMANENT_DELEGATE: () => "El emisor puede mover o quemar tus tokens (delegado permanente): confías en el emisor",
-    DEP_STABLE_ISSUER: () => "Su valor depende de quien la emite y la respalda",
-    DEP_TRUSTED_ISSUER: (d) => "Lo emite " + d.issuer + ", un emisor regulado de los pocos que SolFlag considera de confianza. Como cualquier emisor, puede congelar o retirar tokens por orden legal",
-    DEP_KNOWN_ISSUER: (d) => "Lo emite " + d.issuer + ": puede crear, congelar o mover tokens, como cualquier emisor regulado. Confías en el emisor",
-    DEP_NONE: () => "No depende de un emisor ni de un puente"
-  },
-  offSolana: " y su mercado principal puede estar fuera de Solana",
-  levels: {
-    HIGH: "Riesgo alto", MEDIUM: "Riesgo medio", LOW: "Riesgo bajo", SPAM: "Probable spam",
-    NO_DATA: "Sin comprobar", NO_MARKET: "Sin mercado", MEDIUM_DATA_ONLY: "Medio por falta de datos"
-  },
-  types: {
-    STABLE: { label: "Stablecoin", note: "Se juzga por su liquidez y por la confianza en quien la emite; la concentración pesa menos." },
-    TOKENIZED: { label: "Tokenizado o regulado", note: "Lo normal es que el emisor tenga control (delegado permanente). El riesgo real es confiar en el emisor y que haya liquidez para salir." },
-    BRIDGED: { label: "Puenteado o de protocolo", note: "Lo normal es que un programa controle el mint. El riesgo real es confiar en ese puente y que su mercado en Solana sea pequeño, porque el principal puede estar en otra red." },
-    CREATOR: { label: "Con control del creador", note: "Una wallet puede crear más tokens o congelar cuentas: es el patrón típico de estafa, así que se juzga con más dureza." },
-    OPEN: { label: "Token abierto", note: "Sin autoridades del creador, típico de memecoins y proyectos nuevos. Pesan sobre todo la concentración en personas y la liquidez." }
-  },
-  lights: { control: "Control del creador", concentration: "Concentración", market: "Mercado y salida", dependency: "Dependencia" },
-  missing: { control: "quién controla el token", concentration: "la concentración de holders", market: "el mercado", dependency: "la dependencia de un emisor" },
-  steps: {
-    address: "Comprobando la dirección…", wallet: "Leyendo la wallet…", markets: "Consultando precios y liquidez…",
-    tokens: "Revisando tokens…", token: "Leyendo el token…", owners: "Buscando a quién pertenece cada cuenta…",
-    kinds: "Distinguiendo wallets de pools y programas…", bots: "Separando personas de bots y exchanges…",
-    funders: "Buscando wallets con el mismo origen de fondos…", exchangeSources: "Comprobando si el origen de cada grupo es un exchange…",
-    creator: "Mirando quién creó el token (RugCheck)…", creatorTokens: "Revisando otros tokens del creador…",
-    networks: "Comprobando cuánto tienen hoy las redes de wallets…", wallets: "Leyendo wallets…",
-    pnl: "Estimando el resultado de cada wallet…", done: "Listo"
-  },
-  notes: {
-    PNL_NO_HELIUS: "No se estimó el resultado de las wallets porque falta una clave de Helius.",
-    PNL_PARTIAL: "No se pudo leer el historial de algunas wallets.",
-    PNL_APPROX: "No se pudo obtener el histórico de precio de SOL: se usó el precio de hoy y los resultados pueden estar muy alejados de la realidad."
-  },
-  errors: {
-    CANCELLED: () => "Cancelado.",
-    INVALID_ADDRESS: () => "Esa dirección no parece de Solana. Son de 32 a 44 letras y números y no empiezan por 0x.",
-    NOT_A_TOKEN: () => "Esa dirección no es un token.",
-    IS_NFT: () => "Esa dirección es un NFT, no un token. El escáner no revisa NFTs.",
-    NO_HOLDERS: () => "El RPC no devolvió datos de holders.",
-    HELIUS_REQUIRED: () => "Para estimar el resultado hace falta una clave de Helius (o una URL de RPC de Helius con la clave).",
-    SOL_PRICE: () => "No se pudo obtener el precio de SOL para calcular el resultado. Prueba otra vez dentro de un rato.",
-    DEX_UNREACHABLE: () => "No se pudo conectar con DexScreener. Revisa tu conexión a internet y prueba otra vez.",
-    TOO_FEW_WALLETS: (d) => d && d.filter ? "Solo " + d.n + (d.n === 1 ? " wallet cumple" : " wallets cumplen") + " el filtro de resultado (de " + d.total + " leídas)." : "Hacen falta al menos 2 wallets que se puedan leer.",
-    TOO_FEW_TOKENS: () => "Pega al menos 2 direcciones de tokens de Solana.",
-    NETWORK_PUBLIC: () => "Los servicios gratuitos de Solana no han respondido (a veces se saturan). Espera un minuto y prueba otra vez, o usa tu propia URL de RPC (Helius tiene plan gratuito).",
-    NETWORK_OWN: () => "No se pudo conectar con tu URL de RPC. Revisa que esté bien copiada (con la clave al final).",
-    UNKNOWN: (d) => "Algo ha fallado: " + d.message + ". Prueba otra vez o usa otro RPC."
-  }
-};
+// Spanish texts: the same wording the original single-file scanner used
+function usd(n) {
+  if (!n) return "0 $";
+  if (n < 0.01) return "<0,01 $";
+  // de-DE instead of es-ES: same format (dot thousands, comma decimals), but es-ES does not group
+  // 4-digit numbers and "6494 $" showed next to "22.505 $"
+  return n.toLocaleString("de-DE", { minimumFractionDigits: n < 1000 ? 2 : 0, maximumFractionDigits: n < 1000 ? 2 : 0 }) + " $";
+}
+function pct(n) { return Math.round(n) + "%"; }
+function short(a) { return a.slice(0, 4) + "…" + a.slice(-4); }
+function prog(d) { return d && d.prog >= 20 ? ". Los pools y programas guardan el " + pct(d.prog) : ""; }
+
+const EXT = {
+  permanentDelegate: "El emisor puede mover o quemar tus tokens (delegado permanente). Es normal en acciones tokenizadas, pero hay que confiar en el emisor",
+  transferHook: "Tiene transfer hook: ejecuta código externo en cada transferencia",
+  transferFeeConfig: "Cobra una comisión en cada transferencia",
+  nonTransferable: "No se puede transferir",
+  defaultAccountState: "Las cuentas nuevas pueden crearse congeladas"
+};
+
+export default {
+  fmt: { usd: usd, pct: pct, short: short },
+  signals: {
+    NO_INFO: () => "No se pudo leer la información del token",
+    MINT_BY_PROGRAM: () => "El mint lo controla un programa (suele ser un puente o un protocolo): hay que confiar en ese código",
+    MINT_ACTIVE: (d) => "El creador todavía puede crear más tokens (mint activo" + (d && d.byWallet ? ", en manos de una wallet" : "") + ")",
+    FREEZE_BY_PROGRAM: () => "El freeze lo controla un programa: puede congelar cuentas según su código",
+    FREEZE_ACTIVE: (d) => "El creador puede congelar cuentas (freeze activo" + (d && d.byWallet ? ", en manos de una wallet" : "") + ")",
+    EXTENSION: (d) => EXT[d.ext] || ("Extensión " + d.ext),
+    NO_MARKET: () => "No hay mercado en DexScreener (sin precio ni liquidez)",
+    MARKET_UNCHECKED: () => "No se pudo consultar el mercado de este token (fallo de red al conectar con DexScreener): vuelve a analizarlo para comprobarlo",
+    KNOWN_TOKEN: () => "Token muy conocido",
+
+    CTL_MINT_ACTIVE: () => "El creador puede crear más tokens (mint activo)",
+    CTL_FREEZE_ACTIVE: () => "El creador puede congelar cuentas (freeze activo)",
+    CTL_TRANSFER_HOOK: () => "Ejecuta código externo en cada transferencia",
+    CTL_TRANSFER_FEE: () => "Cobra una comisión en cada transferencia",
+    CTL_NON_TRANSFERABLE: () => "No se puede transferir",
+    CTL_DEFAULT_FROZEN: () => "Las cuentas nuevas pueden crearse congeladas",
+    CTL_ONLY_PROGRAMS: () => "Solo hay autoridades controladas por un programa (ver dependencia)",
+    CTL_KNOWN_ISSUER: (d) => "Lo controla su emisor, " + d.issuer + " (ver dependencia)",
+    CTL_NONE: () => "Sin autoridades activas: nadie puede crear más ni congelar",
+    CTL_SERIAL_CREATOR: (d) => "El creador ha lanzado " + d.n + " tokens más en las últimas 24 h (según RugCheck): es un lanzador en serie, que suele abandonar cada token en cuanto llegan compradores",
+    CTL_SERIAL_PAYER: (d) => "La wallet que pagó este lanzamiento ha lanzado " + d.n + " tokens más en las últimas 24 h (contado en la cadena): es un lanzador en serie, que suele abandonar cada token en cuanto llegan compradores",
+    BRAND_COPY: (d) => "Usa el nombre de " + d.brand + ", una empresa real que no tiene token en Solana: no es oficial, casi seguro una imitación para atraer compradores",
+    BRAND_NAME: (d) => "Usa el nombre de " + d.brand + ", una empresa real: no es un token oficial de " + d.brand,
+    COPYCAT: (d) => "Hay " + (d.n === 1 ? "otro token" : d.n + " tokens más") + " con el mismo nombre y ticker; el más antiguo con mercado real (" + short(d.original) + ", de hace " + d.days + (d.days === 1 ? " día" : " días") + ") no es este: comprueba que tienes la dirección correcta",
+    HOLD_GROUP: (d) => d.n + " holders recibieron su primer SOL de la misma wallet y juntos tienen el " + pct(d.pct) + " del suministro: probablemente son la misma persona o equipo",
+    CTL_CREATOR_HISTORY: (d) => "De los " + d.old + " tokens que el creador lanzó antes (hace más de 24 h), " + d.dead + " se quedaron por debajo de 10.000 $ de capitalización (según RugCheck): sus lanzamientos no suelen despegar",
+    IMPOSTOR: (d) => "No es el " + d.symbol + " original. Comprueba que es el token que buscas",
+
+    CON_SKIPPED: () => "Sin comprobar la concentración de holders",
+    CON_UNAVAILABLE: () => "No se pudo comprobar la concentración de holders (el servicio no respondió; prueba otra vez en un rato)",
+    CON_ALL_POOLS: (d) => "Casi todo el supply está en pools o programas" + prog(d),
+    CON_OK: (d) => "Sin concentración preocupante (mayor wallet individual: " + pct(d.w1) + ")" + prog(d),
+    CON_TRUSTED: (d) => "No cuenta: en un token de " + d.issuer + " los grandes holders son su tesorería, custodios, exchanges y protocolos",
+    CON_ISSUER: (d) => "La mayor wallet tiene el " + pct(d.w1) + " y las 10 mayores el " + pct(d.w10) + ": con un emisor verificado suelen ser su tesorería, custodios, exchanges o protocolos, no cuenta como riesgo" + prog(d),
+    CON_HIGH: (d) => "La mayor wallet individual tiene el " + pct(d.w1) + " y las 10 mayores el " + pct(d.w10) + " del supply" + prog(d),
+    CON_UNSPLIT: (d) => "No se pudo separar pools de personas. La mayor cuenta tiene el " + pct(d.top1) + " del supply",
+
+    MKT_LIQ_INFLATED: (d) => "Liquidez inflada: DexScreener dice " + usd(d.reported) + ", pero el pool solo tiene unos " + usd(d.real) + " en tokens de verdad (USDC, USDT o SOL). Es lo máximo que podrías sacar al vender" + (d.reported >= 100 * Math.max(d.real, 1) ? ". Una diferencia así no es casual: está montada para que el token parezca establecido" : ""),
+    MKT_LIQ_VERY_LOW: (d) => "Liquidez muy baja (" + usd(d.liq) + ")",
+    MKT_LIQ_LOW: (d) => "Liquidez baja (" + usd(d.liq) + ")",
+    MKT_VOLUME_LOW: (d) => "Volumen de 24 h casi nulo (" + usd(d.vol) + ")",
+    MKT_NEW: (d) => "Mercado muy nuevo (" + (d.days < 1 ? "menos de un día" : d.days + (d.days === 1 ? " día" : " días")) + ")",
+    MKT_POSITION_HEAVY: (d) => "La posición de esta wallet equivale al " + pct(d.pct) + " de la liquidez: vender de golpe movería mucho el precio",
+    MKT_LP_UNLOCKED: (d) => "Solo el " + pct(d.pct) + " de la liquidez está bloqueada o quemada (según RugCheck): el resto se puede retirar de golpe",
+    MKT_LP_PARTLY_LOCKED: (d) => "Solo el " + pct(d.pct) + " de la liquidez está bloqueada o quemada (según RugCheck)",
+    MKT_OK: (d) => "Liquidez " + usd(d.liq) + " · volumen 24 h " + usd(d.vol),
+
+    DEP_PROGRAM_AUTHORITY: () => "Un programa controla el mint o el freeze (puente o protocolo): hay que confiar en su código",
+    DEP_PERMANENT_DELEGATE: () => "El emisor puede mover o quemar tus tokens (delegado permanente): confías en el emisor",
+    DEP_STABLE_ISSUER: () => "Su valor depende de quien la emite y la respalda",
+    DEP_TRUSTED_ISSUER: (d) => "Lo emite " + d.issuer + ", un emisor regulado de los pocos que SolFlag considera de confianza. Como cualquier emisor, puede congelar o retirar tokens por orden legal",
+    DEP_KNOWN_ISSUER: (d) => "Lo emite " + d.issuer + ": puede crear, congelar o mover tokens, como cualquier emisor regulado. Confías en el emisor",
+    DEP_NONE: () => "No depende de un emisor ni de un puente"
+  },
+  offSolana: " y su mercado principal puede estar fuera de Solana",
+  levels: {
+    HIGH: "Riesgo alto", MEDIUM: "Riesgo medio", LOW: "Riesgo bajo", SPAM: "Probable spam",
+    NO_DATA: "Sin comprobar", NO_MARKET: "Sin mercado", MEDIUM_DATA_ONLY: "Medio por falta de datos"
+  },
+  types: {
+    STABLE: { label: "Stablecoin", note: "Se juzga por su liquidez y por la confianza en quien la emite; la concentración pesa menos." },
+    TOKENIZED: { label: "Tokenizado o regulado", note: "Lo normal es que el emisor tenga control (delegado permanente). El riesgo real es confiar en el emisor y que haya liquidez para salir." },
+    BRIDGED: { label: "Puenteado o de protocolo", note: "Lo normal es que un programa controle el mint. El riesgo real es confiar en ese puente y que su mercado en Solana sea pequeño, porque el principal puede estar en otra red." },
+    CREATOR: { label: "Con control del creador", note: "Una wallet puede crear más tokens o congelar cuentas: es el patrón típico de estafa, así que se juzga con más dureza." },
+    OPEN: { label: "Token abierto", note: "Sin autoridades del creador, típico de memecoins y proyectos nuevos. Pesan sobre todo la concentración en personas y la liquidez." }
+  },
+  lights: { control: "Control del creador", concentration: "Concentración", market: "Mercado y salida", dependency: "Dependencia" },
+  missing: { control: "quién controla el token", concentration: "la concentración de holders", market: "el mercado", dependency: "la dependencia de un emisor" },
+  steps: {
+    address: "Comprobando la dirección…", wallet: "Leyendo la wallet…", markets: "Consultando precios y liquidez…",
+    tokens: "Revisando tokens…", token: "Leyendo el token…", owners: "Buscando a quién pertenece cada cuenta…",
+    kinds: "Distinguiendo wallets de pools y programas…", bots: "Separando personas de bots y exchanges…",
+    funders: "Buscando wallets con el mismo origen de fondos…", exchangeSources: "Comprobando si el origen de cada grupo es un exchange…",
+    creator: "Mirando quién creó el token (RugCheck)…", creatorTokens: "Revisando otros tokens del creador…",
+    networks: "Comprobando cuánto tienen hoy las redes de wallets…", wallets: "Leyendo wallets…",
+    pnl: "Estimando el resultado de cada wallet…", done: "Listo"
+  },
+  notes: {
+    PNL_NO_HELIUS: "No se estimó el resultado de las wallets porque falta una clave de Helius.",
+    PNL_PARTIAL: "No se pudo leer el historial de algunas wallets.",
+    PNL_APPROX: "No se pudo obtener el histórico de precio de SOL: se usó el precio de hoy y los resultados pueden estar muy alejados de la realidad."
+  },
+  errors: {
+    CANCELLED: () => "Cancelado.",
+    INVALID_ADDRESS: () => "Esa dirección no parece de Solana. Son de 32 a 44 letras y números y no empiezan por 0x.",
+    NOT_A_TOKEN: () => "Esa dirección no es un token.",
+    IS_NFT: () => "Esa dirección es un NFT, no un token. El escáner no revisa NFTs.",
+    NO_HOLDERS: () => "El RPC no devolvió datos de holders.",
+    HELIUS_REQUIRED: () => "Para estimar el resultado hace falta una clave de Helius (o una URL de RPC de Helius con la clave).",
+    SOL_PRICE: () => "No se pudo obtener el precio de SOL para calcular el resultado. Prueba otra vez dentro de un rato.",
+    DEX_UNREACHABLE: () => "No se pudo conectar con DexScreener. Revisa tu conexión a internet y prueba otra vez.",
+    TOO_FEW_WALLETS: (d) => d && d.filter ? "Solo " + d.n + (d.n === 1 ? " wallet cumple" : " wallets cumplen") + " el filtro de resultado (de " + d.total + " leídas)." : "Hacen falta al menos 2 wallets que se puedan leer.",
+    TOO_FEW_TOKENS: () => "Pega al menos 2 direcciones de tokens de Solana.",
+    NETWORK_PUBLIC: () => "Los servicios gratuitos de Solana no han respondido (a veces se saturan). Espera un minuto y prueba otra vez, o usa tu propia URL de RPC (Helius tiene plan gratuito).",
+    NETWORK_OWN: () => "No se pudo conectar con tu URL de RPC. Revisa que esté bien copiada (con la clave al final).",
+    UNKNOWN: (d) => "Algo ha fallado: " + d.message + ". Prueba otra vez o usa otro RPC."
+  }
+};

package/src/index.js

@@ -49,7 +49,7 @@ export { getTokens, getMint, getConc, getAuthKinds, isMint, accountKinds, kindOf
 export { getMarkets, realLiq, impostorOf, INFLATED_RATIO, geckoLiquidity, geckoPair, brandOf, copiesOf, fakeLiquidity, FAKE_LIQ_RATIO } from "./markets.js";
 export { rugcheckSummary, rugcheckReport, rugcheckGraph, netBalances, creatorLaunches, CREATOR_DEAD_MCAP } from "./rugcheck.js";
 export { score, issuerOf, trustedIssuer, tokenType, buildLights, levelFrom, dataOnly, reasonsFrom, assess, SERIAL_WARN, SERIAL_BAD, HISTORY_MIN, HISTORY_WARN, HISTORY_BAD_MIN, HISTORY_BAD } from "./risk.js";
-export { recentLaunches } from "./launch.js";
+export { recentLaunches, chainLaunches } from "./launch.js";
 export { analyzeToken, analyzeWallet, analyzeAddress, sortResults } from "./wallet.js";
 export { holderBase, markBusy, onlyReceives, PASSIVE_SAMPLE, findFunder, findFunders, clusterByFunder, holderRows, creatorInfo, analyzeHolders,
   perHour, sourceRates, groupList, EXCHANGE_PER_HOUR, YOUNG_DAYS, HOLD_GROUP_YOUNG, HOLD_GROUP_MATURE } from "./holders.js";

package/src/launch.js

@@ -1,6 +1,7 @@
 import { PUMP_PROGRAM } from "./constants.js";
 import { isCancel } from "./errors.js";
 import { pool } from "./util.js";
+import { loadWalletBase, knownType } from "./base.js";
 
 /**
  * Pump.fun tokens a wallet launched in the last 24 h, read on chain from its latest transactions.
@@ -42,3 +43,35 @@ export async function recentLaunches(client, wallet, opts) {
   });
   return { n: mints.length, mints: mints, scanned: day.length, more: sigs.length >= limit && day.length === sigs.length };
 }
+
+/**
+ * The creator's recent launches read on chain, for when RugCheck does not know the token yet (it answers
+ * 400 "unable to generate report" for most tokens a few minutes old, 2026-11-02) or does not answer.
+ * The launcher is the first signer of the token's creation transaction: the wallet that paid, as in
+ * recentLaunches (farms name a fresh creator each time but pay from one wallet). Only new tokens: past
+ * 1000 transactions the creation is too far back to find cheaply.
+ * The wallet is NOT the creator RugCheck names (farms name a fresh one each time), so it comes back as
+ * `payer` with `creator: null`, and the signal is CTL_SERIAL_PAYER with its own text. A wallet the
+ * SolFlag wallet base knows as an exchange or platform (it may pay launches for many unrelated people)
+ * is not counted; opts.base: a base object, or false to skip the check.
+ * Same shape as creatorLaunches, without the history of older launches (that needs market caps):
+ * @returns {creator: null, payer, day, total, old: 0, dead: 0, best: null, chain: true, more} or null
+ */
+export async function chainLaunches(client, mint, opts) {
+  opts = opts || {};
+  const sigs = (await client.rpc("getSignaturesForAddress", [mint, { limit: 1000 }])) || [];
+  if (!sigs.length || sigs.length >= 1000) return null;
+  const p = { encoding: "jsonParsed", maxSupportedTransactionVersion: 1, commitment: "confirmed" };
+  const tx = await client.rpc("getTransaction", [sigs[sigs.length - 1].signature, p]);
+  const keys = tx && tx.transaction && tx.transaction.message && tx.transaction.message.accountKeys;
+  const first = keys && keys.filter(function (k) { return k.signer; })[0];
+  const wallet = first && (first.pubkey || first);
+  if (!wallet || wallet === mint) return null;
+  if (opts.base !== false) {
+    const base = opts.base && typeof opts.base === "object" ? opts.base : await loadWalletBase(client);
+    if (knownType(base, wallet) === "exchange") return null;
+  }
+  const r = await recentLaunches(client, wallet, { now: opts.now, limit: opts.limit });
+  const day = r.mints.filter(function (m) { return m !== mint; }).length;
+  return { creator: null, payer: wallet, day: day, total: day, old: 0, dead: 0, best: null, chain: true, more: r.more };
+}

package/src/risk.js

@@ -4,6 +4,7 @@ import { short, sleep } from "./util.js";
 import { getMint, getAuthKinds, getConc } from "./tokens.js";
 import { impostorOf, brandOf, copiesOf, fakeLiquidity } from "./markets.js";
 import { rugcheckSummary, creatorLaunches } from "./rugcheck.js";
+import { chainLaunches } from "./launch.js";
 
 // Every finding is a "signal": {code, s, data}. `s` is ok | na | warn | bad, `data` holds the numbers
 // behind it. Turning signals into sentences is i18n's job (describe / explainLight), never the engine's.
@@ -131,7 +132,12 @@ export function buildLights(info, conc, pair, value, type, rc, now, launches) {
   }
   // Launch farms put out a token every few minutes and drop each one as soon as buyers arrive: in a
   // 100-token Pump.fun sample one wallet launched 7 copies of "GMS" in 10 minutes
-  if (launches && launches.day >= SERIAL_WARN) it.push(sig("CTL_SERIAL_CREATOR", launches.day >= SERIAL_BAD ? "bad" : "warn", { n: launches.day, creator: launches.creator }));
+  // counted on chain (RugCheck had no report): it is the wallet that paid the launch, not the named creator
+  if (launches && launches.day >= SERIAL_WARN) {
+    const lv = launches.day >= SERIAL_BAD ? "bad" : "warn";
+    it.push(launches.chain ? sig("CTL_SERIAL_PAYER", lv, { n: launches.day, payer: launches.payer })
+      : sig("CTL_SERIAL_CREATOR", lv, { n: launches.day, creator: launches.creator }));
+  }
   // Older launches that went nowhere: farms that spread their tokens over days escape the 24 h count
   if (launches && launches.old >= HISTORY_MIN && launches.dead / launches.old >= HISTORY_WARN) {
     const bad = launches.old >= HISTORY_BAD_MIN && launches.dead / launches.old >= HISTORY_BAD;
@@ -264,7 +270,10 @@ export async function assess(client, mint, pair, opts) {
   const rcPromise = pair ? rugcheckSummary(client, mint) : Promise.resolve(null);   // in parallel with the RPC calls below
   // Serial launching only matters while a token is new; RugCheck's full report is small (~10 KB) then
   const fresh = pair && !opts.skipCreator && (!pair.pairCreatedAt || Date.now() - pair.pairCreatedAt < 7 * DAY);
-  const launchPromise = fresh ? creatorLaunches(client, mint) : Promise.resolve(null);
+  // when RugCheck does not know the creator (new tokens often get a 400) the launches are counted on chain
+  const launchPromise = fresh ? creatorLaunches(client, mint).then(function (r) {
+    return r || chainLaunches(client, mint).catch(function (e) { if (isCancel(e)) throw e; return null; });
+  }) : Promise.resolve(null);
   // Copies of the same name and ticker: one search per token, so only when asked (a single token, not a wallet)
   const copiesPromise = pair && opts.copies && !OFFICIAL_TOKENS[mint] ? copiesOf(client, mint, pair).catch(function (e) { if (isCancel(e)) throw e; return null; }) : Promise.resolve(null);
   let info = null, conc = null;