Skip to main content
Every question flagged during the client-building effort, and how it was resolved. Of the original 8 open items, a dedicated multi-agent research pass closed 6 outright, and live testing against production (see Live validation against production) closed the remaining 2. Two more items (enum numeric values, ShuMei/ACE enforcement) surfaced and were closed during that same live-testing pass, outside the original 8. The 1.0.364 analysis and live work in October 2026 then closed ten more questions and opened several new ones, and a full-coverage pass over the 1.0.364 APK corrected 21 claims across these docs (see the full coverage analysis below). This page tracks all of them, plus the narrow follow-on work that remains.

Status at a glance

This table exists so a future update can change just the relevant row without rewriting the rest of the page. The first ten rows are resolved as originally framed. One of them (established-account reconnect block) grew a narrower follow-on question of its own, whether reconnect still worked after a security fix swapped part of the ta blob for empty placeholders, and that follow-on is now also resolved (confirmed working against the shipped code, August 2026; since the 1.0.370 follow-up the iOS ta fills those fields again, static-analysis-only); the caveat below is kept for the record. The rows after the first ten come from the 1.0.364 pass; the open ones are detailed in Open questions. If a future finding reopens or closes an item, update its row and status here rather than adding a separate list.

Full coverage analysis (1.0.364)

In October 2026, eleven analysis agents went through the whole 1.0.364 APK with one rule: every unit gets accounted for. All of it is static analysis; a fact counts as live only where a line says so.

Method

  • A ledger of units. A script enumerated every unit of the APK into six ledgers: Lua modules, data tables, C# assemblies, Java packages, native libraries, and other files (resources, asset containers, manifests). That’s 22,401 units. Each agent claimed its units by group, and a checker verified that every unit was claimed. The final check reported covered 22401/22401 with no problems. Its 11 “large group” flags are templated families (generated Message classes, Android resource directories, the lw_monster split tables), listed for review, not failures.
  • Four levels of coverage. Every unit reached the first two:
    1. Decompiled or parsed into readable source or structured data: all 18,733 Lua modules (patched unluac), all 1,291 data tables (decompiled and executed into JSON), all 118 C# assemblies (ILSpy), the base APK’s Java (jadx; one method body failed), and all 8,059 bundled UnityFS bundles. The native libraries were not decompiled: they got a symbol and string survey plus targeted arm64 disassemblies.
    2. Mechanically indexed: a script wrote a row for the unit into an index without anyone reading it, for example one row per command with its request params and SFS2X types, per C# type, per data table, and per bundle.
    3. Summarized at group level (summarized): the unit is covered by its group’s write-up, which came from the index plus a read of the group’s key files. That’s 17,574 units, typically views, list cells, templated Message classes, vendor and platform libraries, resources, and art.
    4. Read line by line (read): 4,827 units, the logic layers: protocol, state managers, controllers, and bootstrap.
“Covered” doesn’t mean “read”. The main caveats: no native library was read, only surveyed; 3,022 of the 3,104 Message classes were parsed by script, and hand-checked samples matched on request params in 84 of 84 cases and on response fields in 77 of 84; and inside Assembly-CSharp, 130 types (about 11,500 lines) were read line by line while the other 3,539 were summarized from the type index and key methods. Anti-cheat and anti-fraud code (Tencent ACE, ShuMei, psh, the init.add challenge, login.ext, the probe template, and client-computed mini-game validation) was inventoried as a surface only, never analysed. psh’s iOS formula was later recovered from the iOS binary, see Identity, login & session.

Headline results

  • The command surface, fully indexed. 3,115 MsgDefines commands, each with its request params and SFS2X types, the response fields its handler reads, and every one of its 4,561 send sites with the guards around them. 54 more commands exist only in C#, and the chat table adds 133 wire names. See Command reference.
  • 159 game systems mapped, each with its managers, init fields, pushes, commands, timers, and resets.
  • 21 corrections to these docs, now applied. The largest:
    • The C# runtime is FM_Mono (Mono 6.13.0), not HybridCLR.
    • The world map does stream a viewport, through C#-owned block pulls, and season maps are 3000×3000.
    • hotUpdateMsg is name,version,size,crc32, and resVersion’s tail is local state.
    • The native chat transport behind CalcChatSign is unreachable, and the two readygo.tech cleartext endpoints are dead.
    • free.building.upgrade.finish and queue.finish are free collects, not paid instant finishes.
    • About 20 commands, not one, report client-computed battle results.
    • The alliance chat room id is deterministic, and Scene/LWHummerScene is the Armed Truck reward’s own 3D scene.
    • The SFS2X library in use is SmartFox2X 1.7.8 plus the game’s own BaseUtils transport; Smartfox2xLw is dead code.
  • New protocol facts, added to the pages they belong on: the server-day boundary and reset events, the reward payload shape, error conventions, the XAssetPro container, the table CDN and split-table layout, the WebSocket preamble, the chat transport, the mini-game PvP transport, and the C#/Lua dispatch order.
  • A claim catalogue: 558 claim-like requests, each with its parameters and the guard at its first send site, hand-traced for 55 of them. Most aren’t in these docs; Command reference summarizes the conventions they share.
  • A never-automate inventory: rewarded ads (the Android build ships no ad SDK at all), rating and survey rewards, account and role deletion, payments and diamond spends, irreversible moves, and client-reported results. Several share a wire name with a free claim and differ by one parameter, so they’re catalogued to keep them out of automation by accident.
  • Two live checks. Check-version returns table_version and locale only for table_env=table_online, and the live table set 39516 differs from the APK’s 39432 in rows only, not in schema (both confirmed live on 2026-10-05).
The full row-level indexes (commands, claim commands, send sites, systems, tables, bundles, C# types) live with the analysis artifacts outside this repo and can be regenerated with the method above.

Resolved in the 1.0.364 pass

  • Does the shipped client send a Handshake?: Resolved no. In 1.0.364, NetConnection handles only a=1 (Login) and a=29 (ping-pong) as system actions, and the connect path runs TCP connect, an a=29 probe, then Login (static-analysis-only). The 2026-10-04 capture of the real iOS app shows no a=0 on any socket. The server still answers a Handshake if one is sent. See SFS2X wire protocol.
  • Why an own-device Login gets E005: Resolved the Android Login sent an empty ta. goclient filled ta only for iOS. C485 found from real Android captures that an Android Login with {} gets E005 and one with the platform markers filled in doesn’t (discussion #22). On 2026-10-13 one build sent the 2026-10-04 own-device token twice, changing only ta: {} got ec=28, ep=[E005], and the filled blob (#os = Android, #bundle_id = com.fun.lastwar.gp, lw_platform = market_global, plus the build and zone keys) logged in (confirmed live). The deviceId shape doesn’t block it, and neither does device trust nine days after binding, since neither changed between the two runs. A guest Login is accepted with either ta. See Identity, login & session.
  • What E005 means: Resolved as far as the client goes. The 1.0.364 C# maps it to ERROR_MAINTENANCE and shows a maintenance dialog without touching credentials. Live, the server also returned it for a token presented under the wrong platform identity, so the label is the client’s UI bucket, not the server’s reason. See Identity, login & session.
  • Tactical Center, Armament Institute, and Truck Station I-IV: Resolved they aren’t production lines. They returned 602026 on all 342 scheduled runs and never status=1 (confirmed live), and none is in the 1.0.364 Lua’s ProductLineBuilds. A 602026 response therefore doesn’t confirm a command pairing. See City & building.
  • The 120471 per-donation cooldown: Resolved it isn’t a cooldown. The free donate path holds regenerating charges (useNum of maxNum, refilled every refreshTimeBlock), and 120471 means none is left (static-analysis-only). See Alliance, chat & mail.
  • What the mail claim’s type holds: Resolved for the real client: an internal mail group id sent as a UtfString. goclient sends the raw mail type as an Int, and the server accepts it (confirmed live). Which value the server reads stays open. See Alliance, chat & mail.
  • Where resVersion’s last two parts come from: Resolved they’re local state. The C# builds the tail from CURRENT_TABLE_VERSION and LOCALE_VERSION, the newest table and locale on the device, built-in or downloaded (static-analysis-only). Check-version does return table_version and locale, but only for table_env=table_online, which goclient doesn’t send (confirmed live on 2026-10-05); that request returned 39516 and 23570, the iOS app’s tail. See Startup, version-check & hot-update.
  • What the forward header’s id means: Resolved statically: it’s the zone number, ParseSid("APS783") = 783 in BaseUtils, which matches the 0x030F in the 2026-10-04 capture. A second capture on another zone would confirm it live.
  • Which id the Alliance Duel detail read takes: Resolved the init entry’s activityid, not its id. The duel’s entry is {id: 55000, activityid: "70000"}, and ActivityInfoData lets activityid override id (static-analysis-only). Asked for "55000", the server answers a bare {success=true}; asked for "70000", it returns the full eventList (both confirmed live on 2026-10-06). The live entries carry their day window as st/et. See Alliance Duel.
  • Whether an items-only speed-up touches diamonds: Resolved for build.ccd.m.new. With only itemIDs, the reply’s remainGold equaled the starting balance and itemCostArr listed every item spent (confirmed live on 2026-10-06). queue.ccd.m.new and building.camp.accel haven’t been sent live yet. See Live validation against production.
  • Whether at.time is an issue time or an expiry: Resolved an issue time. A GSL opt=login response on 2026-10-04 carried at.time and rt.time equal to the moment of issue, in unix seconds (confirmed live), consistent with the 1.0.364 client’s 30-day refresh rule. Whether the server also expires tokens on its own, and so what caused the 2026-10-02 rotation, stays open. See Live validation against production.

Open questions

These came out of the 1.0.364 static analysis and the October 2026 live work. Static analysis can’t settle any of them; each needs a live observation.
  • Minimal ta content. Reconnect works with ta’s device sub-fields blank (confirmed live), and an Android Login into an established account needs it filled (confirmed live, see the resolved E005 item above). Which keys the server reads hasn’t been isolated: the A/B tests compared {} with the whole blob, and the platform markers (#os, #bundle_id, lw_platform) are only the likely ones.
  • dataConfigMd5 persistence. The real client sends a server-issued value; in the 2026-10-04 capture it equaled init.add.a from the same session. Comparing init.add.a across two captures of the same app build would show whether the client persists it or the server echoes back whatever arrives. This is an integrity surface, so the question is about understanding the protocol, not about sending the value.
  • Does opt=refresh rotate rt? The real client stores whatever non-empty rt arrives. If a refresh rotates rt, a token pair shared between the real app and a Go client keeps working only for whichever side refreshes first. On 2026-10-13, eight days after issue, three refreshes of the own device’s pair each returned the current at with its original at.time and no rt (confirmed live). A third party reports the same for an iOS own-device pair, a few minutes after issue (discussion #56). What a refresh returns once at is 30 days old is still open. See Identity, login & session.
  • Can two devices hold working sessions for one account? This decides whether a Go client with its own device identity could keep its own tokens alongside the real app’s. The 1.0.364 role-switch flow (email verification, loginKey, GSL opt=login) is how a device gets its own pair. GSL issued one to a newly bound Go-generated device on 2026-10-04, and that device’s Login was accepted on 2026-10-13 (both confirmed live). The same night a second Go device was bound and logged in, and the first device’s config still logged in afterwards, so their tokens coexist (confirmed live). Each Login takes the role’s one live connection. On 2026-10-13 the scheduled 03:00 PDT run, which uses a token captured from the real iOS app, still logged in after own devices had logged in nine times (confirmed live, one run; see Identity, login & session). What hasn’t been seen is whether the real app’s 30-day refresh invalidates an own device’s pair.
  • Which command collects the Tactical Chip Factory? The 1.0.364 Lua reads both ways: BuildBubbleManager sends building.camp.collect {uuid} for chip buildings, and the factory’s own UI sends chip.collect {}. One read of the factory’s building_new entry in a captured init, then one capture of the real collect tap, would settle it. See City & building.
  • Does the live init carry real_timezone_offset? The C# applies it only when present, and the Lua falls back to UTC without it, which would move its day boundary from 02:00 to 00:00 UTC while tomorrow stays at 02:00. The 2026-10-04 capture shows the key in the Login response; listing the top-level keys of a captured init would settle it. See Identity, login & session.
  • Does the server check platform on opt=refresh? The real iOS client sends platform=iOS. goclient sends platform=iOS under -cs-ios and Android otherwise. A refresh token is scarce, so whether the server checks that field hasn’t been tested. A third party reports a refresh of an iOS own-device pair working (discussion #56). goclient sends that refresh with platform=iOS under iosMode, the platform the pair was issued under, so a mismatch is still untested.
  • status=0 from building.production.collect. The Lua treats only a missing or -1 status as failure; every live success has carried status=1.
  • When does each Alliance Duel action book its points? Radar tasks book at the claim (confirmed live, 2026-10-07): each receive.detect.event.reward was followed by push.act.score.obtain with addScore, and detect.event.help.end produced none. Still open for UR secret tasks, power gains, and troop training: start, finish, or claim. goclient now logs every push.act.score.obtain with the request sent before it, which answers this per action from ordinary runs. See Alliance Duel.
  • Are unclaimed duel chests mailed at the day’s end? A mail template for it exists in the locale; no live observation yet.
  • Is an empty or over-count itemIDs charged in diamonds? An empty itemIDs on queue.ccd.m.new is the client’s own diamond instant finish (ArmyManager.lua:204-210), and for a running research inside the free research time (init effect 30100) the client’s free finish (UIScienceView.lua:648-654). What the server does with more items than are owned is unknown. goclient never sends an over-count or an empty itemIDs, so this stays a static reading.

Resolved by live testing

See Live validation against production for full methodology.
  • Does a finished radar task survive its endTime?: Resolved yes (confirmed live, 2026-10-06). Nine tasks finished but left unclaimed were still listed by get.detect.info in state 1, 46 minutes after their endTime. The unclaimed rescue task among them was kept too. Only unstarted tasks expire.
  • Enum numeric values (BuildingTypes, …): Resolved the authoritative BuildingTypes table lives in Global_EnumType.lua, giving every building’s internal codename and numeric ID directly. See the Game entity ID reference for the full extraction across buildings/monsters/units/heroes/resources/items.
  • Whether the server enforces ShuMei/ACE anti-cheat data on login: Resolved no ShuMei-specific block exists, as far as live testing shows. Reconnecting to an account with real history first looked ShuMei-gated, but that block turned out to be a token-identity mismatch (see the reconnect bullet below). On 2026-10-04 a captured iOS session reconnected into the established account with shumeiBoxId sent empty (confirmed live), and new-guest-account creation never needed it. Full test matrix in Live validation against production.
  • The missing post-login init push: Resolved none of the three previously-identified leads were the cause. The real bug: packet.go’s ReadPacket already correctly detected the server’s Zstandard-compressed packets (header bits 0x20 compressed + 0x10 useLZ4-repurposed-as-Zstd) but decompression itself was never implemented, it just returned an error, which every read loop indistinguishably treated as “connection closed.” Fixed by adding a real Zstd decoder (github.com/klauspost/compress/zstd, a shared lazily-initialized zstd.Decoder) in that same branch. The post-login init push turned out to be ~313KB of Zstd-compressed SFSObject data on the wire; decoding it surfaced two further binary-codec bugs in sfsobject.go: LONG_ARRAY/FLOAT_ARRAY/DOUBLE_ARRAY/BOOL_ARRAY/SHORT_ARRAY (tags 9, 11, 13, 14, 15) were simply unimplemented, and BYTE_ARRAY (tag 10) was decoded with the wrong length-prefix width (i16 instead of the real i32), silently corrupting decode of any packet containing one, see the corrected wire-format table in SFS2X wire protocol. Once both were fixed, the init push arrived cleanly on the very first attempt: no reconnect loop, no extended timeout needed, and the active-pull login.init fallback never had to fire. Of the two mechanisms built earlier to chase this symptom, only the three-attempt reconnect-on-timeout loop was unnecessary and has been removed (max login attempts back to 1); the halfway active-pull login.init send inside waitForInitPush was kept in place, unconditionally, as a real, still-exercised fallback for a genuinely silent server, not reverted, see Live validation against production for the full mechanism split.
  • The established-account reconnect block: Resolved not anti-fraud, not device fingerprinting, not session locking. Captured live traffic from the real iOS/Mac-Catalyst app (/Applications/Last War.app) via tcpdump against the same account, decoded the Login packet field by field (the SFS2X game socket is plain TCP, no TLS), and confirmed by a byte-for-byte raw replay that the same access token works cleanly across repeated connections, it is not single-use, and there is no rate-limit or already-connected mechanism. The actual gate: a token is bound to the exact packageName/platform/appVersion/versionCode identity it was issued under, and goclient hardcoded an Android identity unconditionally even when replaying an iOS-issued token. Fixed in identity.go (BuildLoginParams gained an IOSMode switch covering packageName, packageSign, confirmed still SHA1(packageName) on iOS too, platform, pf, appVersion, versionCode, the iOS-only idfa/idfv/phone_native_screen fields, removal of Android-only fields, and, at the time, populating ta with real captured content instead of an empty placeholder), plus crossserver.go and new -cs-ios/-cs-at flags in main.go. A real reconnect through the Go client’s own from-scratch SFS2X implementation then succeeded cleanly: Login OK, followed immediately by a correctly Zstd-decoded init push showing the account’s 162 real buildings. Caveat: the exact minimal required content of ta wasn’t isolated, only that the full real captured blob worked, at the time of that capture. A later security fix replaced ta’s LwDeviceID/LwShumeiID/LwAirKey sub-fields with empty-string placeholders (they were leaking the same live device secrets in cleartext inside an opaque JSON string); reconnect is now re-confirmed working with those placeholders against the shipped code, an unattended cron running this client reconnected and collected real resources over multiple days (August 2026), re-verified after a live zone-server migration, so the server does not require ta’s real device sub-fields (August 2026; since the 1.0.370 follow-up the iOS ta fills lw_device_id/lw_airKey from the Login and lw_shumei_id from the cached shumeiId, or replays a captured ta; a live config-copy test is pending before the cron uses it: a copy without a shumeiId takes two runs, the first run’s Login sending lw_shumei_id empty and saving the pushed shumeiId and the second sending it, while a copy that already has one, such as a recapture with pcap -session-out, sends it from its first run; see Client 1.0.370). What’s left is even narrower: the minimal required ta content still isn’t isolated (a different token needs its own fresh ta regardless, since session-specific fields live inside it). An Android from-scratch login is live-confirmed; -cs-ios now sends the iOS identity from the first GSL call, and that path hasn’t been tried live, see Live validation against production.

Resolved by a dedicated research pass

Full findings, with file:line citations into the client source, follow below.
  • March “recall home” encoding: Resolved not a coordinate sentinel, it’s the literal enum constant MarchTargetType.BACK_HOME = 3 (Global_EnumType.lua:3945), sent in the ordinary target field of world.march.change (the same command used to redirect a march anywhere), with path set back to the player’s home-city tile. Full call chain traced from the UI button through to the wire request.
  • WorldPointInfo.proto’s actual transport: Resolved the “no confirmed call site” framing was outdated: world.get.new and world.get.block’s response field points (an array of raw byte blobs) is decoded via WorldPointInfo.Parser.ParseFrom in WorldPointManager.ParseWorldGetBlock, feeding the ~30 concrete point-type classes that render the world map. A second, nested call site decodes march destination points the same way.
  • Four unrecoverable proto schemas: Resolved all four (ScoreProgressInfo, WorldCityRankMail, LwScoutReport, ShieldInfo) were fully recoverable, and not where prior analysis stopped looking, see the callout below.
  • libxlua.so’s CalcChatSign/AES/MD5 helpers: Resolved the “no call site” claim was a tooling false-negative (this environment’s grep is ugrep, which silently skips binary files without -a). The real call site was already sitting in report 06 (ChatNetManager:InitWebSocketInst, an alternate native-transport branch). That branch turned out to be unreachable in 1.0.364: only the armeabi-v7a libxlua registers rg_websocket, arm64’s luaopen_native doesn’t, and LuaEntry:__InitCModule(), the only code that would expose the native socket, is never called, so chat always uses the C# ChatService (static-analysis-only). The formula finding stands. Direct ARM64 disassembly of the native function (it ships unstripped, with symbols) confirms it’s exactly MD5(MD5(appId+uid) + timestamp), plain, unkeyed, textbook MD5, byte-identical to the already-known C# formula. Proprietary-crypto risk downgraded from “unknown” to confirmed none.
  • PlayerInfo:GetABTestTableName: Resolved not a hash or local computation, it’s a single server-pushed integer, monopoly_ab, delivered in the post-login Init payload’s user object. Each value (1, 2, 3, 5, 6, 7, 8, 9, 10, 13, 16, 18 in this build) is a reserved slot for one named A/B test; the function’s Is<TestName>B() checks compare against it directly. A reimplementation cannot derive this offline, it must be read from a real login response.
  • Season vs. Activity domain boundary: Resolved (accuracy-measured, not just re-asserted): a genuine random sample of 100 commands (50 Season, 50 Activity) checked against actual handler code came back 97% label-defensible. The 3 confirmed misclassifications aren’t random noise, they’re all cases where a single feature’s sibling commands got torn across both domains because the classifier operates per-command/per-folder rather than per-DataCenter-manager (e.g. the Desert Storm fishing minigame’s 8 commands split ~50/50 because one cmd string happened to contain "fish.pond", a substring the classifier’s ordered rule list catches before the generic "season" fallback).
Bonus finding: 18 proto schemas recovered, not just 4. The “unrecoverable” verdict on the four proto schemas stopped at “not in the Lua bundle” without checking two other places they actually live. Three of the four (ScoreProgressInfo, ShieldInfo, LwScoutReport) turned out to have full Google.Protobuf-generated C# classes in Assembly-CSharp.decompiled.cs, each embedding its complete compiled FileDescriptorProto as a base64 blob. All four, WorldCityRankMail included, which has zero C# presence at all, are also physically shipped as Unity TextAssets inside a custom-packed AssetBundle blob (assets/AssetBundles/BundleFragment0.bytes, 525MB, indexed by a name→offset table also in the APK). Locating and extracting that bundle’s gameres_main_dir_proto entry recovered all 18 .proto.bytes files the client ships (not just the 4 originally sought) as serialized FileDescriptorSet binaries, decoded to human-readable .proto text and cross-validated field-for-field against the independently-recovered C# descriptors. Both the raw binaries and decoded schemas are saved at extracted/recovered_protos/*.proto / *.decoded.txt.