@gala-chain/launchpad-sdk 8.1.0 → 9.0.0-rc.1

package/CHANGELOG.md

@@ -1,5 +1,842 @@
 # Changelog
 
+## 9.0.0-rc.1
+
+Since 9.0.0-rc.0 (published): the sections "App-owned session" through "The stream socket" below
+(the app-session, browser-wallet, bundle-confirmation, error-answer, path-parameter, `PageInfo`,
+`fetchPools`, admin/overseer, trades/tokens/users/streaming and stream-socket contracts) and the
+later entries of "BREAKING CHANGES" and "Fixes" are new in rc.1; everything else in this section is
+rc.0's. Core peer floor is `>=1.0.0-rc.6 <2`.
+
+launchpad-sdk is launchpad-only. Everything that speaks to the GalaChain gateway generically is
+`@gala-chain/gala-core-sdk`'s (a peer dependency: install it beside launchpad-sdk); everything that
+speaks to the swap backend (dex-backend) is `@gala-chain/gswap-sdk`'s, and launchpad-sdk no longer
+depends on it in any way. **[MIGRATING-TO-9.0.md](./MIGRATING-TO-9.0.md)** lists every export and
+`LaunchpadSDK` member 8.1.0 had that 9.0.0 does not, with its new home; it is generated from the
+built declarations of both versions (`pnpm docs:migration`).
+
+### BREAKING CHANGES (9.0 cut)
+
+- **The `Sign` header goes to the launchpad backend only.** The clients for the GalaChain gateway,
+  dex-api (referrals, bridgeable and wrappable token lists), the swap backend (prices) and the
+  bundler no longer send it: none of those hosts reads it (the gateway's own signature is in each
+  write's body; dex-api reads `x-wallet-address`), and every header cost a wallet signature per
+  request, a prompt for browser wallets. The clients keep the wallet identity (`getAddress`,
+  `signTypedData`) services read from them. `HttpClient` takes `{ signRequests }` as its third
+  constructor argument (default true: the launchpad backend client). Gateway read goldens
+  (`gateway-reads`, `token-discovery`) lost exactly their recorded `Sign` header and nothing else;
+  `tests/http-client-sign-header.test.ts` pins both behaviours.
+- **No DEX at all, not even as a devDependency.** The 46 DEX demos and their npm scripts (`demo:dex*`,
+  `demo:liquidity*`, `demo:fees*`, the pool watchers, `test:demos:dex`, `test:demos:fees`) moved to
+  `packages/gswap-sdk/examples/demos` (on gswap-sdk's own client, type-checked by its
+  `check:examples`), and the stage live test's DEX checks to gswap-sdk's live test.
+  `tests/product-boundary.test.ts` scans `src`, `tests`, `examples` and `scripts` with the TypeScript
+  scanner, refuses gswap-sdk in every dependency field and resolves it from the package with plain
+  Node (MODULE_NOT_FOUND); the CI dist check refuses it in every bundle.
+- **Prices: launchpad tokens only.** Of the two swap-backend price readers launchpad-sdk had, only the
+  launchpad-token one stays: `fetchTokenPrice({ tokenName })` (the bonding-curve price, or the
+  token's swap-backend price once it graduated; GALA's USD price and a graduated token's price are
+  read with a thin `GET /market/price` documented as launchpad-backend-adjacent). REMOVED, as
+  generic swap-backend reads that gswap-sdk's `market` already makes:
+  `fetchTokenPrice({ tokenId })` (a `tokenId` is now refused with a `ValidationError` before
+  anything is sent) and its 400/404 "launchpad fallback" (the recorded golden vector shows it never
+  fired: the 404 was wrapped before the check), `fetchGalaPrice()`, `fetchPriceHistory()`,
+  `fetchAllPriceHistory()` and their types (`FetchPriceHistoryOptions`, `PriceHistoryResult`,
+  `PriceSnapshot`, `PriceSortOrder`). Use `gSwap.market.getPrice(tokenId)` and
+  `gSwap.market.getPriceSeries(await sdk.resolveTokenClassKey(name), timeframe)`.
+  Decision and evidence (callers grepped in mcp-server, the apps, examples and docs): the only
+  callers of the removed reads were the MCP price tools, the examples and the docs. The MCP tools
+  (`gala_launchpad_fetch_token_spot_price` with `tokenId`, `..._fetch_gala_spot_price`,
+  `..._fetch_price_history`, `..._fetch_all_price_history`) keep their names, inputs and outputs on
+  the MCP server's own GSwap client, and replay the 13 recorded 8.1 vectors of these reads (same
+  endpoint and query, same outputs). What differs on the wire: no launchpad `Sign` header on these
+  public reads, the `$` of a class key sent as `%24`, and a backend failure's inner text (gswap-sdk's).
+- **Dependencies are the source's import graph** (`tests/dependency-graph.test.ts`): `@gala-chain/api`,
+  `axios`, `bignumber.js`, `ethers`, `socket.io-client`, `uuid`, `web-file-polyfill`; peers
+  `@gala-chain/gala-core-sdk` (`>=1.0.0-rc.3 <2`), `zod` (now `^4.3.6`: the peer said `^3` while the
+  schemas are zod 4, and it is no longer also a dependency) and the shared libraries. No longer
+  dependencies: `@solana/web3.js`, `@solana/spl-token`, `dotenv`, `@modelcontextprotocol/sdk` (and,
+  since the bridge move, `bs58` and `json-stringify-deterministic`).
+- **Bridging is explicit: the `bridge` loader.** The bridge, balance-on-chain, token-list and wrap
+  methods run on `@gala-chain/gala-core-sdk/bridge` (the one core entry that loads `ethers`,
+  `@solana/web3.js` and `@solana/spl-token`, core's optional peers), which the app hands over:
+  `new LaunchpadSDK({ ..., bridge: () => import('@gala-chain/gala-core-sdk/bridge') })` (type
+  `CoreBridgeLoader`; a page without a bundler passes a function resolving to the module it loaded
+  itself). The UMD bundle no longer looks for a `GalaCoreSDKBridge` global. launchpad-sdk
+  names neither that module nor Solana in any built bundle: a bundler (Vite, webpack, Metro)
+  resolves every load it sees, a lazy `import()` included, so the earlier `import()` inside the SDK
+  made every app's build need Solana (an app's Vite build failed with 13 `MISSING_EXPORT` errors on
+  `@solana/web3.js` / `@solana/spl-token`). Without the loader a bridge or wrap call is a
+  `ConfigurationError` (`field: 'bridge'`) naming it; with it, the module is loaded once per SDK at
+  the first such call, and a failed load (the peers are not installed) is a `ConfigurationError`
+  naming them, tried again at the next call. `check:pack` scans every built bundle of the packed
+  package for a `@gala-chain/gala-core-sdk/bridge` or `@solana/*` load (`scripts/runtime-specifiers.ts`).
+  A bridge or wrap call made with one wallet is refused (`ConfigurationError`, nothing sent) if
+  `setWallet` / `setWalletProvider` runs while `/bridge` loads, rather than running as the next
+  wallet. `getSupportedBridgeTokens()` is `async`.
+- **The public surface re-exports nothing** (`tests/public-surface.test.ts` pins both entries' export
+  lists and fails on any export declared outside `src/`). Removed from the main and `/native`
+  entries: `generateEIP712Types` and `GalaChainSigner` (core's), the duplicate EIP-712 types
+  `EIP712Types`, `EIP712TypeField`, `EIP712Domain` (core's `EIP712Types`, `EIP712DomainValue`),
+  `HttpRequestor` (the bundler transport takes core's `HttpRequestor` type), `GALA_TOKEN_CLASS_KEY`
+  (core's), `generateUniqueKey` (core's `createUniqueKey`), and the demo `.env` loaders `getEnv`,
+  `getEnvOrThrow`, `loadEnvWithFallback`.
+
+### App-owned session (a browser app's httpOnly-cookie JWT session)
+
+- **`session` in `LaunchpadSDKConfig`.** A browser app (launchpad-frontend-v3) keeps its own JWT
+  session: the refresh token is an httpOnly cookie the backend sets for `cookieSession: true`
+  logins, and the app is the one token authority. With `session: { accessToken, onUnauthorized,
+  credentials? }` every launchpad-backend request takes its bearer from `accessToken()` (awaited per
+  request), a 401 goes to `onUnauthorized(rejectedToken)` and is retried once with the token it
+  returns (`null`: the 401 stands), the launchpad-backend client sends credentials (unless
+  `credentials: 'omit'`), and the SDK stores no token (services that attach "the JWT" attach
+  nothing; the client adds the session's bearer). No other host (gateway, bundler, dex-api, swap
+  backend) ever sees the session or credentials. Exclusive with `accessToken`. Pair it with
+  `signer` + `walletAddress`: `wallet` / `walletProvider` sign every launchpad request (`Sign`).
+- **`loginWithSignature({ address, message, signature, publicKey? })`**: `POST /auth/login` with a
+  signature the caller made (a browser wallet signs `Sign in to Launchpad t:<ms>` itself); with a
+  session it asks for the cookie session and stores nothing. **`loginWithDevBypass(address)`**: the
+  backend's non-production signature bypass.
+- With a session, `refreshToken()` is `POST /auth/refresh` with `{}`, no bearer and the cookie;
+  `logout({ allDevices, accessToken })` always revokes on the server (bearer as handed over, never
+  refreshed); `ensureValidToken()` is the session's current token. Auth-endpoint failures are an
+  `AuthError` with the backend's `statusCode` (401/403: the session was rejected; 429/5xx/none:
+  transient). `tests/app-session.test.ts` drives each through a real axios instance.
+
+### Browser-app wallet signing
+
+- **`BrowserWalletSigner.fromEip1193(provider, keyAddress, options?)`**: a browser app holds the
+  wallet's raw EIP-1193 provider, not an ethers one. The factory builds the ethers `BrowserProvider`
+  the typed-data path reads the network and the selected account from, keeps the raw `request` for
+  `signObject`, and takes the key as `0x` or `eth|` (a `client|` alias is refused: it names no key).
+  The bytes are those of the constructor path (bundler-typed-data and wallet-providers goldens
+  unchanged; `tests/wallet-signers-app.test.ts` compares both paths over a real `BrowserProvider`).
+- **`WALLET_ACCOUNT_CHANGED`** (`LaunchpadSDKError`, `details.walletAccount` / `signerAccount`):
+  `BrowserWalletSigner` refuses to sign when the wallet's selected account is not its key. Same
+  message as before; it was a plain `Error`, which the bundler transport rewrapped as
+  `LAUNCHPAD_SIGNING_FAILED`.
+- **`WALLET_USER_REJECTED`**: the bundler transport tells a decline in the wallet (gala-core-sdk's
+  `isWalletUserRejection`: `4001`, `ACTION_REJECTED`, Gala Wallet's decline, core's
+  `SIGNING_FAILED`/`user_rejected`) apart from other signing failures, with the wallet's code in
+  `details.walletCode`. Other failures stay `LAUNCHPAD_SIGNING_FAILED`; an SDK error passes through.
+- **Gala Wallet typed data selects the account.** `GalaWalletSigner.signTypedData` switches the
+  extension (`setAddress`, where it offers it) to `selectAddress`, else the Ethereum account the
+  request names, inside gala-core-sdk's per-wallet select-then-sign queue
+  (`withGalaWalletIdentity`), and signs through the `wallet` option when one is given (it read
+  `window.gala` even then, while `signObject` used the option).
+- **`GalaWalletSigner` option `verifyActiveAccount` (default `false`)**: the app's check before a Gala
+  Wallet signature. On, the signer reads the wallet's active account (`wallet.address`, else
+  `eth_accounts` when the wallet has not reported one since the page loaded) and refuses with
+  `WALLET_ACCOUNT_CHANGED` (`details.walletAccount` null when none was reported) unless it is the
+  signer's key; the RPC order is that check, `setAddress`, `eth_signTypedData`. Off by default so the
+  six recorded `galaWalletEthAddress` vectors of `bundler-typed-data.golden.json` are unchanged (the
+  check adds an `eth_accounts` request); the opt-in sequences are pinned by the new
+  `tests/golden/gala-wallet-verify-account.golden.json`. A signer that names no Ethereum key
+  (`client|` alias without an Ethereum `selectAddress`) is refused at construction
+  (`INVALID_SIGNER_OPTIONS`). `BrowserWalletSigner` needs no option: it always compares the wallet's
+  selected account with its key.
+
+### Bundle confirmation for a browser app
+
+- **`bundleSocketFactory` in `LaunchpadSDKConfig`** (passed to `BundlerTransport`): the app's own
+  bundler socket, with its reconnect settings. Each `wait()` adds its listener for the bundle's
+  event on the socket the factory returns and removes it when the wait ends; that socket is never
+  disconnected (a socket the transport opens itself still is).
+- **`sdk.launchpad.attach({ bundleId, method, uniqueKey, tokenName? })`** (and
+  `BundlerTransport.attach`): a `BundleSubmission` for a bundle sent before a reload, whose `wait()`
+  confirms exactly as the original's (socket event raced against the REST confirmation, which also
+  answers for a bundle that settled while nobody listened). Nothing is signed or sent until
+  `wait()`. Refused with `INVALID_BUNDLE_ATTACHMENT` (`details.field`): empty `bundleId` /
+  `uniqueKey`, a method the bundler does not accept, a `CreateSale` without `tokenName`. New exports:
+  `LAUNCHPAD_WRITE_METHODS` (`LaunchpadWriteMethod` is now derived from it), types
+  `BundleAttachment`, `BundleSocket`, `SocketFactory`. `LaunchpadWriteTransport` gains `attach`.
+- The bundler (bundler-backend origin/main, `src/socket/socket.gateway.ts`) emits only
+  `{ status, data }` (lowercase; `PENDING` / `PROCESSED` / `FAILED`), never `{ Status, Data }`, so
+  `parseBundleResult` is unchanged.
+
+### The backend's error answer on `NetworkError`
+
+- **`serverMessage`, `serverError`, `details`, `body`** (type `NetworkErrorServerAnswer`) beside
+  `statusCode`. Before, an HTTP failure was `NetworkError("HTTP <M> <url>: Request failed with status
+  code N")` and the backend's body survived only on `originalError.launchpadError`. The launchpad
+  backend (origin/main `GlobalExceptionFilter`) answers `{ status, error: true, message }`
+  (HttpException: validation pipe, `sendResult`, guards) or `{ statusCode, message }` (CustomError,
+  413, unhandled 500): `serverMessage` is that `message` (an array is joined with `,`, as
+  `String(array)` shows it), `serverError` is a string `error` only (`true` is not one), `body` the
+  whole body (or the text of a non-JSON answer). Messages are unchanged.
+- **A wrapped NetworkError keeps them**: `new NetworkError(msg, status?, originalError?, answer?)`
+  takes the answer of `originalError` (an axios error's response, or another NetworkError) when
+  not given, and `handleNetworkError` (the `error-wrapper` `withErrorHandling` wrap services put
+  around the client's error) also takes the wrapped NetworkError's status: it was `undefined`
+  there. (A bare `createNetworkError(msg, undefined, inner)` does not take the status: the
+  gateway-reads golden pins `statusCode` absent on the GalaChain balance read's wrapped 400.)
+  `createNetworkError` takes the answer as an optional fourth argument;
+  `response-handlers.assertResponseSuccess` puts a 2xx error envelope's body on it.
+- Paths that turned the client's NetworkError into another error now keep it a NetworkError, same
+  message: `PoolService.fetchToken`'s 404 "Token not found: <name>" (was a plain `Error`),
+  `UserService.uploadProfileImage`'s "Profile image upload failed: ..." for an HTTP refusal (was a
+  `ValidationError` `UPLOAD_FAILED`; other failures still are), and `LaunchpadPriceService`'s spot
+  price failure now wraps the original.
+- The response interceptor's `launchpadError.error` is set only when the body's `error` is a string
+  (it cast the backend's `true` to a string).
+
+### Path parameters are spelled as the backend compares them
+
+- `buildEndpoint` (every `StreamTokenServiceBase` service) lowercased EVERY path value. It now
+  follows `PATH_PARAM_CASING`, decided per parameter from launchpad-backend origin/main's routes:
+  `tokenName` (the pool lookup's `normalizeTokenName`), `address` and `userAddress`
+  (`normalizeAddress`) stay lowercased; `assetId` and `targetId` (Mux ids, mixed-case, compared
+  exactly), `id` (numeric invite ids) and `code` (invite codes, matched exactly) are sent as given.
+  A parameter the table does not name is refused. Changed on the wire: `getRecordingDownload` /
+  `deleteRecording` (`/v1/tokens/:tokenName/recordings/:assetId[/download]`) and
+  `removeSimulcastTarget` (`/v1/tokens/:tokenName/simulcasts/:targetId`): a mixed-case Mux id was
+  lowercased into one the backend does not have; the moderator and overseer `getInviteByCode`
+  (`/v1/{moderator,overseer}-invites/code/:code`) send the code as given (generated codes are
+  lowercase hex, so only a code typed in another case differs); the invite `:id` routes are
+  unchanged in effect (digits).
+
+### `PageInfo` is the backend's `pageInfo`
+
+- **`PageInfo` = `{ hasNextPage, endCursor?, hasPreviousPage?, startCursor?, totalCount? }`**, the
+  backend's own keys (launchpad-backend origin/main `buildPageInfo`: `endCursor` / `startCursor`
+  are `string | null`). It declared `nextCursor` / `prevCursor` / `hasPrevPage`, while every list
+  but two passed the backend's `pageInfo` through unchanged (so at run time it was `endCursor`), and
+  `PoolService` / `UserService` renamed the backend's keys to the declared ones. Now no list renames:
+  pools and user token lists return the backend's `pageInfo` (`pageInfoOf`, which drops a field of
+  the wrong type), and the cursor walkers (`autoPaginateWithCursor`, `fetchAllPools`, the vault
+  token-name lookup) follow `endCursor` (`nextCursorOf`): `autoPaginateWithCursor` stopped after
+  the first page of every passed-through list. They also stop when the backend repeats the cursor
+  just used (`fetchAllPools` went back to page 1 on a missing cursor).
+- `totalCount` is set only on results the SDK assembles from every page (`fetchAll...`): the
+  backend sends no count. Removed with it: `UserTokenListResult.total` (always undefined), the
+  dead `InternalFetchUserBalancesResponse` type, and the top-level `count` / `total` / `nextCursor`
+  / `prevCursor` / `hasNextPage` / `hasPrevPage` fields of the internal pool and user-list response
+  types (the backend answers `{ tokens | token | launches, pageInfo }`). Migration: read
+  `pageInfo.endCursor` (`?? undefined` for a `cursor` option) where you read `nextCursor`.
+
+### `fetchPools` matches `GET /v1/tokens` (launchpad-backend origin/main `FetchPoolDto`)
+
+- **`type` and `streamStatus` in the backend's spelling, any case.** `type` RECENT / POPULAR /
+  RECORDINGS / SECONDS_STREAMED (`POOL_FETCH_TYPES`; the backend compares case-sensitively, so it is
+  sent uppercase), `streamStatus` IDLE / ACTIVE / DISABLED (`POOL_STREAM_STATUSES`). The lookup
+  tables were lowercase-keyed and DROPPED the app's `'POPULAR'` / `'ACTIVE'` without a word; lowercase
+  still works. A value the backend does not accept is a `ValidationError`, never dropped.
+- **`pageSize` 1 to 100** (`POOL_LIST_MAX_PAGE_SIZE`, the backend's `MediumListQueryDto` maximum):
+  it was silently clamped to 20. Larger, zero or fractional is a `ValidationError`. `fetchAllPools`
+  reads pages of 100 (was 20). Default still 10.
+- `recentlyStreamed` (integer 1 to 720), `language` (ISO 639-1) and `search` (at most 255) are
+  checked before sending, as the backend would refuse them.
+- **`hasUpcomingShows` / `hasRecordings`: only `true` is sent.** The backend's boolean conversion
+  (`@Type(() => Boolean)` with implicit conversion) reads `"false"` as true, so `false` used to turn
+  the filter ON; it now sends nothing (no filter).
+- `isGraduated` / `creatorAddress` are NOT added: origin/main's `FetchPoolDto` has neither and the
+  pipe forbids unknown properties (a 400).
+- One pool-list reader: the private `LaunchpadAPI.fetchPools` / `fetchPoolsFromAPI` copy (used to
+  find a vault's token name for a sell-fee quote) is removed; that lookup reads `PoolService`. The
+  copy read `hasNextPage` / `nextCursor` at the top of `data`, where the backend never puts them,
+  so it never got past page 1. `LaunchpadService` / `fetchAllPools` take `FetchPoolsOptions` (their
+  inline option types still named `offset` / `limit`). The zod `poolFetchTypeSchema` takes all four
+  types; the public `PoolFetchType` is the one type (`'RECENT' | 'POPULAR' | 'RECORDINGS' |
+  'SECONDS_STREAMED'`, it was the schema's two).
+
+### Admin and overseer contracts (launchpad-backend origin/main)
+
+- **`revokeOverseerInvite` and `revokeOverseer` sent no Authorization.** The auth headers were passed
+  in the query-params slot of `HttpClient.delete`: the request went out unauthenticated and the
+  header names became query parameters. They are headers now (`tests/g3-admin-wire.test.ts`).
+- **Restricted token names carry the session bearer.** `getRestrictedNames` / `updateRestrictedNames`
+  (Overseer-only routes) sent no Authorization. An empty `content` is accepted (the backend takes any
+  string; it clears the list); `UpdateRestrictedNamesResponse` is `{ content }` (the backend echoes the
+  stored content), it was typed `{ success: true }`.
+- **Invite codes are validated like the backend**: any non-empty string up to 64 characters
+  (`INVITE_CODE_CONSTRAINT.MAX_LENGTH`, was 100 for overseer codes and "64 hex" for moderator codes).
+  An unknown code is the backend's 404, which a claim page relies on to fall through from the overseer
+  lookup to the moderator one; it used to be a client-side `ValidationError`.
+- **`sdk.getHealth()`** (`GET /health`, public): `HealthCheckResponse` (`status` plus database, redis,
+  mux, rabbitmq, galachain_query, galachain_launchpad). A critical dependency down is HTTP 503 and
+  throws a `NetworkError`.
+- **`sdk.getEventStats()`, `sdk.queryEvents(options)`** (`GET /v1/events/stats`, `GET /v1/events`,
+  Admin API key or Overseer): the routes answer BARE bodies, which the service reads and shape-checks.
+  `queryEvents` pages by `page` / `limit` (1..100). `eventTypes` / `categories` are sent as a
+  REPEATED key (one value is sent twice): the backend validates them with `@IsArray` behind Express 5's
+  simple query parser, where a comma list or `key[]=` is refused.
+- **`getMessageStats` reads the bare object** `GET /v1/messages/stats` answers (it required a
+  `{ data }` envelope and could never succeed against the backend).
+
+- **The flag filters validate what `GetFlagsQueryDto` takes**: the token filter is 1-50 letters and digits
+  (a 1-character filter threw; see the token name rules below) and the addresses
+  (`reporterAddress`, `reportedUserAddress`, also `createFlag`'s) are the forms `@GalaChainAddressField()`
+  takes after its normalisation: `eth|<40 hex>`, `0x<40 hex>`, 40 hex, `client|<24 hex>` or 24 hex
+  (`isBackendUserAddress` / `assertBackendUserAddress`). A bare client id is accepted now; a partial
+  address and `client|<name>` stay refused, because the backend answers 400 for them.
+- **`updateModeratorInvite({ inviteId, description: '' })` is a valid update**: the backend's `UpdateModeratorInviteDto.description` has no minimum and its service updates on
+  `description !== undefined`, so `''` alone clears the label (the SDK refused it with "At least one of
+  role or description"). An update with neither field is still refused.
+
+### Trades, tokens, users and streaming contracts (launchpad-backend origin/main)
+
+- **`fetchTrades` reaches its route.** It sent the literal `/v1/tokens/:tokenName/trades` with the
+  name in a query parameter; the token is now in the path (lowercased, as the backend compares it).
+  `TradeQueryItem` types `tokenSymbol`, which `GET /v1/trades` returns. `getTrades` already unwrapped
+  the `{ data }` body (verified on the wire, `tests/g3-trades-wire.test.ts`).
+- **`fetchTokenStats` returns what the backend sends**: `{ holdersCount, chatMessageCount, commentCount,
+  roomCount }` (`TokenStatsData`, was `EngagementStatsData`). It required a `stats` wrapper the backend
+  has none of, and so could never succeed; `totalEngagement`, participants and activity fields were
+  never sent.
+- **`updateTokenConfig` takes `chatEnabled`** (was `messagesEnabled`, which the backend refuses with 400:
+  its `UpdateTokenConfigDto` has `chatEnabled`).
+- **`fetchLaunchpadFee()` returns the number** (`data.feeAmount`); it returned the `{ feeAmount }` object
+  typed as a number.
+- **Images reach their routes.** `uploadImageByTokenName` posts to `/v1/tokens/:tokenName/image` (the
+  placeholder went out literally, the name in a query parameter) and `uploadProfileImage` to
+  `POST /v1/users/me/image` (it used the token route); the profile upload needs no address or wallet.
+- **`updateProfile` sends what is given.** `address` is optional (validated, not sent), `fullName` and
+  `profileImage` are optional (at least one), `profileImage: ''` clears the image, and the profile is no
+  longer fetched first to send the old image back. `fullName` is validated like the backend's
+  `UpdateProfileDto` (a trimmed 2..20 letters, one optional second word) and no wallet is required, only
+  a JWT.
+- **User token lists take pages up to 100** (`USER_PAGINATION_CONSTRAINT.MAX_LIMIT` 20 -> 100; the
+  backend takes up to 1000, default 50); `getManagedTokens` sends no `pageSize` unless asked, so the
+  backend's 50 applies (the SDK's default 10 cut a longer list off).
+- **`fetchVolumeData` returns the chart**: `{ dataPoints, isPreviousData, nextTime? }` with the candles
+  typed as the backend sends them (`startTime`, `openPrice`, `highPrice`, `lowPrice`, `closePrice`,
+  `volume`); `dataPoints` held the whole `{ data, isPreviousData }` object typed as `{ timestamp, value }[]`.
+- **`getTradeQuote` takes an `AbortSignal`** (`TradeQuoteParams.signal`); `PlatformStatsData` volumes are
+  numbers (typed as strings); `listOverseerUsers` accepts `ASC` / `DESC` (the backend reads the order
+  case-insensitively).
+- **Recordings match `GET /v1/tokens/:tokenName/recordings`**: a bare array with no paging.
+  `getStreamRecordings({ tokenName })` returns `{ recordings, tokenName }` (the fabricated `page`, `limit`,
+  `total`, `hasNext` are gone; the old code read `data.recordings` and could never succeed). A recording is
+  `{ id, playbackId, status, duration, createdAt, masterAccess, aspectRatio?, assets? }` (was `assetId`,
+  `tokenName`, `downloadable`, `fileSize`, `thumbnailUrl`); `RECORDING_STATUS` is Mux's `preparing` /
+  `ready` / `errored`. An unknown token is a `NetworkError` with `statusCode` 404.
+- **Simulcasts match `/v1/tokens/:tokenName/simulcasts`**: the list is a bare array behind the owner's
+  session bearer (it was sent without Authorization); a target is `{ id, url, status, passthrough? }`;
+  `addSimulcastTarget` sends `{ platform, url, streamKey, passthrough? }` with the platform in lowercase
+  (`'youtube' | 'twitch' | 'facebook' | 'custom'`, `SIMULCAST_PLATFORM`), as the backend's
+  `CreateSimulcastTargetDto` requires (it refused `rtmpUrl`, `name` and uppercase platforms), and the
+  URL is RTMP or RTMPS only (the SDK allowed SRT, which the backend refuses).
+- **`sdk.getChatStatus(tokenName)`** (`GET /live/:tokenName/chat`, public): `{ enabled, tokenName,
+  reason?, slowModeSeconds?, status? }`. `ChatStatusResponse` gains `tokenName` and `slowModeSeconds`.
+- **The pinned message is the backend's `PinnedMessageData`** (`messageId`, `content`, `userAddress`,
+  `pinnedBy`, `pinnedAt`, `user?`, `holderTier?`): `getPinnedMessage` returned a type with `id` and
+  `createdAt` the backend never sends, and threw when nothing was pinned (`{ data: null }`); it returns
+  `{ message: null }` now. `getPinnedChatMessage` / `pinChatMessage` return that message as it is, and
+  `unpinChatMessage` takes its `messageId`.
+- **`UpdateMessageOptions.type`**: a chat edit is capped at 500 characters before it is sent when the
+  type is known (`updateChatMessage` passes it).
+- **`PoolData` names the streaming fields the backend sends**: `muxPlaybackId`, `muxStreamAspectRatio`,
+  `streamLanguage` (typed `playbackId`, `aspectRatio`, `language`, which the backend does not send, so
+  they were always undefined); `streamEnabled`, `messagesEnabled`, `commentsEnabled` are not on a pool.
+- **New `sdk.getUserGalaBalance(address)`** (`GET /v1/users/:address/gala-balance`, public: the GALA
+  balance and USD value the backend reads) and **`sdk.fetchReferralCode()`**
+  (`GET /v1/connect/users/referrals/code`, JWT: `{ code, username? }`).
+- **`TradesQueryResult` is the one trades result type, and it is not deprecated.** `getTrades`,
+  `getRecentTrades` and `getHolderHistory` return the backend's `{ trades, pageInfo }`; the
+  `@deprecated` marker (it pointed at `TradesListResult`, an `items`/`meta` type no method returns) and
+  `TradesListResult` are gone, and the `getTrades` examples read `pageInfo` (they destructured a `meta`
+  the result never had).
+- **`UpdateTokenConfigOptions` is one type.** The package root exported a `token-config.dto` interface
+  (social links `string` only) while `updateTokenConfig` took a second one declared beside the message
+  types (`string | null`). The backend's `UpdateTokenConfigDto` takes `null` to clear a social link, so
+  the one type is the `string | null` form, declared in `token-config.dto` with
+  `validateUpdateTokenConfigOptions` (moved with it), and the dead duplicate
+  `InternalUpdateTokenConfigResponse` of `messages.dto` is gone.
+- **The pin and invite result types are exported, one meaning per name.** `pinMessage` / `unpinMessage`
+  return `PinMessageResult` (`{ success }`) and `getPinnedMessage` returns `PinnedMessageResult`
+  (`{ message }`), both now exported from the root; the root's old `PinMessageResult`
+  (`{ tokenName, pinnedMessage }`, the shape of a removed REST route) is gone and
+  `getPinnedChatMessage` / `pinChatMessage` return `GetPinnedMessageResult`
+  (`pinnedMessage` is `null` when another moderator unpinned between the pin and the read back; it was
+  cast to non-null). `InviteScope`, `UpdateInviteRoleOptions` and `UpdateInviteRoleResult` are exported;
+  the identical `InviteScope` of `streaming.dto` and `ModeratedTokenInviteScope` are the one
+  `InviteScope`.
+- **`fetchProfile` is typed and unwrapped.** `fetchProfile(address)` returned the whole
+  `{ status, error, message, data }` envelope typed `unknown`; it returns `PublicUserProfile` (the
+  backend's `ProfileResponse`: `address`, nullable `fullName` / `profileImage` / `bio`, `stats`
+  (`ProfileStats`), the four `BadgeStatus[]` ladders, `isLiveStreaming`, `liveStreamToken`) and a body
+  that is not that shape is a `NetworkError` (`Malformed profile response`). The service's no-address
+  form (`GET /v1/users/me/profile`, JWT) returns `CurrentUserProfile`. `BadgeStatus`, `ProfileStats`,
+  `PublicUserProfile` and `CurrentUserProfile` are exported.
+- **`PoolData` types `badges`** (`PoolBadges`: the `volume` and `engagement` `BadgeStatus[]` ladders the
+  backend builds for `GET /v1/tokens` and `/:tokenName`) and the stored `volumeBadge` / `engagementBadge`
+  columns. The pool route sends no `chatEnabled`, `streamingEnabled` or `tokenSymbol` (they are not in
+  its attribute list), so `PoolData` does not declare them.
+- **Message, comment and chat types are the backend's five shapes** (`GET /v1/messages` and the four write
+  answers differ; the SDK typed one invented `BaseContentItem` for all of them). `Message` is the list
+  item of `fetchMessages`, `getComments` and `getChatMessages`: `id` and `messageId` (the same string),
+  `user` / `userProfile` (the same non-null `{ fullName, profileImage }`), `updatedAt` `string | null`,
+  `reactions: { counts, userReacted? }` (was a plain `Record<string, number>`), and no `type`,
+  `holderTier` or `isPinned` (the backend sends none of them on a list item). Writes: `sendChatMessage`
+  returns `SentChatMessage` (no database id, `holderTier?`), `createComment` / `updateComment` return
+  `WrittenComment` (numeric `id` AND `messageId`, no `tokenName`), `updateChatMessage` returns
+  `EditedChatMessage` (numeric `id`, `reactions?` as `ReactionData`); `createMessage` / `updateMessage`
+  infer the result from `options.type`. `BaseContentItem`, `CommentItem`, `ChatMessageItem`,
+  `isChatMessageItem` and the dead `/v1/comments` result types (`CommentData`, `FetchCommentsResult`,
+  `PostCommentResult`, `FetchCommentsOptions`, `PostCommentOptions`, `DeleteCommentOptions`, file
+  `comment.dto.ts`) are gone; `isMessage` checks the real shape (it needed a `type` no item has, so it
+  was false for every item). Each id the examples took from a write (`result.comment.id`, a number, or
+  `result.message.id`, undefined) is the `messageId`.
+- **Each method validates the token name of ITS backend route** (launchpad-backend origin/main). The SDK
+  refused names the routes take (3-20 everywhere, 2-20 on messages, 50 on trades) and sent names a route
+  refuses. Five rules, exported as `TOKEN_NAME_*_CONSTRAINT` (and `TokenNameConstraint`), replace
+  `LAUNCHPAD_TOKEN_NAME_CONSTRAINT`, `RELAXED_TOKEN_NAME_CONSTRAINT`, `EXTENDED_TOKEN_NAME_CONSTRAINT`
+  and the helpers' silent 3-20 default (`validateTokenName(name, field, constraint)`,
+  `isValidTokenName(name, constraint)`, `validateOptionalTokenName(...)` now take the route's rule):
+  `DTO` 1-20 letters and digits (`@TokenNameField()` request fields: `fetchPools` filter, `fetchVolumeData`,
+  `fetchTokenDistribution`, `fetchUserHolderContext`, `fetchMessages`, `createMessage`, `getTrades`,
+  flag create, moderator invites, `banToken`), `FILTER` 1-50 (the flag lists), `PATH` letters and digits
+  1-255 (a raw `:tokenName` the pool lookup resolves, no format check: `fetchToken`, `fetchTokenStats`,
+  `updateTokenConfig`, `getTokenConfig`, image upload, every stream, recording, simulcast, ban and chat
+  method, `getPinnedMessage`, the user token list filter), `AVAILABILITY` 1-50 characters, any
+  (`validateToken`, `checkPool`: `ValidateTokenDto`), `EVENT` 1-100 characters without HTML (the
+  `WebSocketAdminService` emits). The root helpers `validateTokenName(name, field, constraint)`,
+  `isValidTokenName(name, constraint)` and `validateOptionalTokenName(name, field, constraint)` take the
+  rule of the route you name (they had a silent 3-20 default). The chain's launch rule (letters and
+  digits, 1+, no cap; what the launch form and `createSale` take) is `tokenNameSchema`,
+  `launchTokenDataSchema` and `imageUploadOptionsSchema`; `graphDataOptionsSchema` and
+  `graduateTokenOptionsSchema` use the DTO rule (`dtoTokenNameSchema`) and `checkPoolOptionsSchema` the
+  availability rule (`availabilityTokenNameSchema`). `TRADES_QUERY_CONSTRAINTS` (a deprecated
+  composite) is gone.
+- **The reaction routes take no token name.** `AddReactionDto` is `{ messageId, reactionType }` and the
+  backend refuses any other property (whitelist + forbidNonWhitelisted), so `addContentReaction` with a
+  `tokenName` answered 400; `AddContentReactionOptions` / `RemoveContentReactionOptions` lose
+  `tokenName` and nothing is validated or sent for it.
+- **`uploadTokenImage` and `uploadProfileImage` work on a signer-plus-address SDK.** The facade threw
+  "Wallet is required" (and `uploadProfileImage` defaulted the address from the wallet) though
+  `POST /v1/tokens/:tokenName/image` and `POST /v1/users/me/image` read the user from the session JWT and
+  need nothing else; an app configured with `{ signer, walletAddress, session }` and no `wallet` uploads
+  with the session bearer (`tests/g7-uploads-wire.test.ts`). `uploadProfileImage` no longer invents an
+  address: one that is given is validated and left out of the request. Their JSDoc described
+  `imagePath` options and a Node-only API that do not exist (the options are `{ file }`).
+- **Image uploads send multipart, not JSON.** Both uploads put the `FormData` through an axios instance
+  that carries `Content-Type: application/json` as an instance default; the request-level header was only
+  left out, so the default survived the merge and axios serialised the body as JSON
+  (`{"image":{}}`, the file lost; the 400 the backend answers was the only sign). `HttpClient` now
+  clears the Content-Type for a `FormData` body per request (an explicit `undefined`), so the transport
+  sets `multipart/form-data` with its boundary (axios' Node adapter, the browser's XHR). The existing
+  wire tests swapped the whole instance for one without the default and could not see it;
+  `tests/image-upload-multipart-wire.test.ts` (Node, real server) and
+  `tests/image-upload-multipart-browser-wire.test.ts` (jsdom XHR, real server, plus the FormData as it
+  leaves axios) run the real `createHttpExecutor` instance and read the bytes sent. These are the only
+  two multipart paths in the SDK.
+- **One name for an image upload.** `UploadImageByTokenNameOptions.options.tokenName` (a second name that
+  went into the URL without being validated) is gone; the path takes the validated `tokenName`. The dead
+  `LaunchpadAPI.uploadImageByTokenName` (`POST /launchpad/upload-image`) and
+  `LaunchpadAPI.fetchTokenDistribution` (`GET /holders/:tokenName`), routes the backend does not have, are
+  removed with their tests (`ImageService` and `PoolService` are the working ones).
+
+### The stream socket: one registry of subscribers (launchpad-backend origin/main)
+
+`StreamWebSocketService` keeps ONE registry. `sdk.realtime` is the service of an SDK (built with
+`streamWebSocketUrl`, the reconnect settings and the session's token). Every event the backend emits has a
+typed entry on it (`RealtimeEventPayloads`, read from the emit sites, not from the backend's docs).
+
+- **Any number of subscribers per event, per token, per room.** Every `subscribe*` method is synchronous,
+  returns that subscriber's OWN unsubscribe (a second call is harmless) and replaces nobody. The old
+  single callback slots (`globalCallbacks`, `roomCallbacks`, `globalFeedCallbacks`) are gone: a second
+  subscriber used to replace the first and the first's cleanup deleted the second's callback, and
+  `subscribeToStream` on a joined token wiped every other subscriber's callbacks. A subscriber that
+  throws or rejects is logged and skipped; the others are served. `LaunchpadSDK.watch*` are plain
+  subscribers (the fan-out, refcount and room bookkeeping `watchTokenRoomEvent` kept is deleted).
+- **Rooms are refcounted.** A token room, a comment room, the global feed and the events firehose are
+  joined on the FIRST subscriber and left on the LAST; never two server subscriptions for one room. A
+  leave waits for the join's acknowledgement (a subscribe followed at once by an unsubscribe cannot strand
+  the room on the server). A subscribe before the socket is connected registers and joins on connect; with
+  `autoConnect` (default) it also opens the socket. It never throws `NOT_CONNECTED`.
+- **Listeners are registered once per socket**, when it is created (they used to be registered again on
+  every `connect`, so every reconnect doubled every callback), and removed when it is closed.
+- **Reconnect.** The service acts on the Socket's `connect` (the Manager's `reconnect` fires before the
+  socket is connected and used to run `authenticate()` too early). On every connection after the first:
+  re-authenticate FIRST with the token current at that moment (`tokenProvider`, never a remembered
+  one) if the socket was authenticated, THEN re-join every room that still has a subscriber, THEN call the
+  new `onReconnect(listener)` listeners (the app's version never fired, `reconnect` is a Manager event).
+  `onConnectionStateChange(listener)` is new. A server-side `io server disconnect` reconnects (socket.io
+  does not), and so do `connect()` and a new subscribe after socket.io ran out of reconnection attempts
+  (`socket.active` stays true then). `LaunchpadSDKConfig.streamReconnectAttempts` / `streamReconnectDelay` /
+  `streamReconnectDelayMax` reach socket.io (a browser app wants `Infinity`, 1000, 10000); defaults stay
+  5 / 2000.
+- **`authenticate(token?)` returns `Promise<boolean>`** (it returned `void` and threw `NOT_CONNECTED`
+  when not connected): `true` on `authenticated`; `false` on `exception`, `stream_chat_auth_error`, the
+  10 s timeout, a dropped connection, no token, or a newer `authenticate` / `deauthenticate`. The same
+  token on the same connection sends nothing; a different token replaces the pending one and is sent after
+  the server answered the one in flight. `LaunchpadSDK.authenticateStreamWebSocket(token?)` takes the
+  app's token (or the session's) and returns the boolean. The handshake carries no token any more
+  (`StreamWebSocketConfig.authToken` is gone; a static token was presented, expired, on every reconnect).
+- **`deauthenticate()`** (`sdk.deauthenticateStreamWebSocket()`): the server has no message that drops a
+  socket's identity, so an authenticated socket is closed and opened again (subscriptions stay registered;
+  `onReconnect` fires). `setWallet` / `setWalletProvider` call it.
+- **`joinTokenRoom(token)`** holds a token's room with no listener (the room stays joined while its
+  listeners come and go); it returns its own release.
+- **The overseers' firehose** (`subscribeEventsFirehose(listener, filters?)`): one server subscription
+  for all subscribers, joined once the socket is authenticated (it is overseer-only) and again after every
+  re-authentication. The backend's firehose takes no filters, so each subscriber's
+  `{ eventTypes, tokenName, userAddress }` filters are applied client-side.
+- **The comment room.** `COMMENT_*` events are sent to the comment room only; `subscribeCommentCreated`
+  (and the new `Updated` / `Deleted`) now emit `subscribe_comment` (it never did, so it received nothing).
+- **User-room and overseer events are delivered to global subscribers** (`subscribeGlobalModeratorAdded`
+  / `Removed` / `RoleUpdated` / `InviteCreated`, `subscribeGlobalTokenBanned` / `Unbanned`,
+  `subscribeContentFlagged`, `subscribeFlagResolved`, `subscribeAIModerationComplete` / `Failed`,
+  `subscribeUserBanned` / `Unbanned`, `subscribeBanEnforcement`, `subscribeTradeUpdateNotify`,
+  `subscribeBalanceUpdated(token)`, ...), not only to a token room's subscribers.
+- **Feed subscribers are served whether or not the token room is joined.** The backend sends a client in
+  both rooms one copy of an event; the service delivers it to the token subscribers and to the feed
+  subscribers (it used to deliver it to the token room only, never to the feed).
+- **New events with typed payloads**: `STREAM_CHAT_UPDATED`, `STREAM_CHAT_DELETED`, `SLOW_MODE_CHANGED`,
+  `RECORDING_STATUS`, `RECORDINGS_COUNT_UPDATED`, `SIMULCAST_STATUS`, `DOWNLOAD_READY`,
+  `STREAM_CONTROL_STATUS_CHANGED`, `CONTENT_REACTION_ADDED` / `REMOVED`, `COMMENT_UPDATED` / `DELETED`,
+  `CONTENT_FLAGGED`, `FLAG_RESOLVED`, `AI_MODERATION_COMPLETE` / `FAILED`, `POOL_CREATED`,
+  `TRADE_UPDATE_NOTIFY`, `AI_MODERATION_GLOBAL_STATUS`, `EVENT` (firehose), `exception`.
+  `STREAM_COUNTDOWN_UPDATED` / `STREAM_LANGUAGE_UPDATED` are fed from `TOKEN_CONFIG_UPDATED` (the backend no
+  longer emits them separately). `getSiteConfigState()` returns the latest site-wide switches.
+  `subscribeFeedTokenEvents(cb)` hands every feed token event over named (`{ event, data }`).
+- **A second copy of one occurrence is dropped** for the events the backend sends through two rooms a
+  client can be in (`CONTENT_FLAGGED`, `FLAG_RESOLVED`, `AI_MODERATION_*`, `POOL_CREATED`, `OVERSEER_*`):
+  within 5 seconds, by id.
+- **A payload with no usable `tokenName` no longer throws inside the socket listener** (`data.tokenName.trim()`,
+  `data.content.slice`); it reaches the subscribers of the event for every token and none of a token.
+- **The 30-second replay buffer is removed.** It replayed stale events (trade deltas, candles) to a
+  late subscriber as if they were new, and started a timer per event per token; registration now precedes
+  the join, so there is no join race left for it to cover.
+- **Replaced APIs (9.0.0 is unpublished: no shims).** `setGlobalCallbacks` -> `addCallbacks(callbacks)`
+  (adds, returns the remover); `setGlobalFeedCallbacks`, `unsubscribeFromGlobalFeed` and the Promise form
+  of `subscribeToGlobalFeed` -> `subscribeToGlobalFeed(callbacks)` returns an unsubscribe;
+  `connectStreamWebSocket(callbacks)` adds subscribers; `subscribeToStream(token, callbacks)` adds, and
+  `unsubscribeFromStream(token)` removes only what `subscribeToStream` added. `subscribeEngagementStatsUpdated`
+  takes a token. `StreamingEventService` and its `streaming-events` types are deleted: the
+  `LaunchpadSDK.on*` methods they backed never fired (nothing fed them); they are now subscribers of the same
+  registry (`onStreamChatMessage`, `onViewerCountChanged`, `onUserBanned`, ...: every occurrence the socket
+  receives, for any token; join rooms with the `subscribe*` methods or `subscribeToStream`).
+  `disconnect()` releases every subscriber, listener and timer and rejects what is pending; the service can be
+  used again; `dispose()` (called by `sdk.cleanup()`) is final.
+- **Payload types follow the backend**: `UserBannedEvent` / `UserUnbannedEvent` / `BanEnforcementEvent`
+  (`isGlobal`, `isPermanent`, optional `reason` / `expiresAt` / `userAddress`; `tokenName` is `null` for a
+  global ban; the type guards accept the banned user's own copy, which has no address),
+  `TradeExecutedEvent` (+ `symbol`, `icon`), `BalanceUpdatedEvent` (the backend sends no balances),
+  `StreamGlobalStatusEvent` / `StreamChatGlobalStatusEvent` (`updatedAt` optional: `{ enabled }`), and the
+  global-feed token types are the token-room types (the feed copies named other fields). `COMMENT_DELETED`
+  carries `commentId`, not `messageId`.
+
+### Fixes
+
+- `createSale`'s pre-flight refused launches the launch form and the deployed bundler accept (a
+  scheme-less link such as `t.me/x`, a lower-case symbol, a name of 2 or 21-25 characters, a
+  pre-buy of `5.`). It now refuses only what the bundler (fee window, bad words) or the chain
+  (`CreateTokenSaleDTO`, `TokenClass`) refuses: a name of letters and digits (any length), a symbol
+  of letters and digits in any case (the chain upper-cases it; the wire carries it as typed), no
+  link rules, a non-empty description (at most 1000) and image (at most 500), an integer
+  `saleStartTime`, and a plain-decimal pre-buy and curve portions, which are SIGNED in their
+  canonical spelling (`5.` -> `5`, `1.50` -> `1.5`: the chain keeps any other spelling a string
+  and refuses it). Bad words are still refused by the bundler after signing (it fetches the list).
+  `LaunchpadTradeInput`, `LaunchpadExtraFees` and `CreateSaleInput` are exported by name
+  (`@since 9.0.0`), and `LaunchpadTradeInput.extraFees` documents what is sent on a buy.
+- `BundleSubmission.wait()` takes `{ signal?: AbortSignal }` beside `timeoutMs` / `pollIntervalMs`
+  (`@since 9.0.0`). An aborted wait rejects with `LaunchpadSDKError` `BUNDLE_WAIT_ABORTED`
+  (`details.method`, `details.bundleId`; an already aborted signal rejects before a socket is opened
+  or a read sent) and stops what it started: the in-flight read (the requestor gets the wait's
+  `AbortSignal` as `init.signal`), the pause between reads, the deadline timer, its socket listener
+  (an own socket is disconnected, a borrowed `bundleSocketFactory` socket never). Aborting stops
+  watching only; `attach` resumes the bundle. A wait that ends for any reason now stops its reads too
+  (they used to run on until the deadline, up to 10 minutes). Also: one failed confirmation read (an
+  HTTP error, a network error, an unreadable body) no longer rejects the wait with
+  `BUNDLE_REQUEST_FAILED` while the socket can still deliver: reads are repeated every
+  `pollIntervalMs` until the deadline, and only a verdict (PROCESSED / FAILED), the deadline or an
+  abort ends the wait. At the deadline after failing reads the error is `BUNDLE_CONFIRMATION_TIMEOUT`
+  with the last failed read in `details.lastReadFailure` (`{ message, status? }`); the deadline
+  also holds for a read that never answers.
+- `graduateToken` bought `calculateBuyAmountForGraduation`'s `amount` (the GALA cost of the
+  remaining tokens) as the exact-buy token quantity. It buys `remainingTokens`, with the GALA cost
+  as `expectedAmount` (the slippage cap).
+- `subscribeToTokenCreations`: an event field that is missing or not a string is its fallback
+  (`''`, `preBuyQuantity` `'0'`), never `undefined`; `isFinalized` is `true` only for `true`.
+- Demo tooling: `demo:run` ran every selection interactively and counted failed demos as
+  successes (booleans tested with `!= null`); the registry maps each demo's SDK methods, leaves
+  the tooling out (130 demos) and `demo:run:method` / `demo:run:endpoint` exist. 131 more boolean
+  `!= null` tests in the demos and tests (write demos ran their transfer, wrap and unwrap whatever
+  their `EXECUTE_*` flag said) are plain boolean tests, and `tests/constant-boolean-null-check.test.ts`
+  refuses the shape.
+
+### The `/bundle` signing schemes (unchanged bytes; for Andy)
+
+Two schemes post to the bundler's `/bundle`, and both have callers, so both stay:
+`sdk.launchpad.buyWithNative / buyExactToken / sellWithNative / sellExactToken / createSale`
+(`BundlerTransport`) signs EIP-712 typed data (`signTypedData`, the GalaChain domain; pinned by
+`tests/golden/bundler-typed-data.golden.json`): what the live launchpad frontend
+(launchpad-frontend-v3, `signTypedData` / `eth_signTypedData`) and the MCP trading tools send.
+`sdk.buy()` / `sdk.sell()` (`BundleService.buyToken / sellToken`) sign with the signer's
+`signObject` (native for a private key, personal-sign for a browser wallet): the native app calls
+these (`src/sdk/facades/trade.ts`), as do the examples. Retiring `BundleService`'s trade methods
+needs the native app moved to `sdk.launchpad.*` first (which changes the bytes it sends).
+
+### What moved to gala-core-sdk (the extraction steps, from the 8.1.0 baseline)
+
+The gateway token writes (transfer GALA, transfer a token, burn, lock, unlock) moved to
+`@gala-chain/gala-core-sdk` 1.0.0-rc.1 (`GatewayWrites`). `transferGala`, `transferToken`,
+`burnTokens`, `lockTokens` and `unlockTokens` keep their names, signatures, input checks, result
+shapes and error classes and delegate to it; their requests are byte-identical (golden vectors)
+and still go through the SDK's gateway `HttpClient` (the `Sign` header included).
+
+The gateway token READS moved to `@gala-chain/gala-core-sdk` 1.0.0-rc.2 (`GatewayReads`):
+`fetchGalaBalance`, `fetchTokenBalance` (tokenId and MUSIC/GMUSIC routes), `fetchTokenDetails`,
+`fetchTokenClassesWithSupply` and the NFT reads keep their names and signatures and delegate to it,
+through the same clients as before (balances and NFT reads through the gateway `HttpClient` with
+its `Sign` header, token classes through the unauthenticated gateway axios instance). The core peer
+range is now `>=1.0.0-rc.3 <2`.
+
+The wallet providers and the React hooks moved to `@gala-chain/gala-core-sdk` 1.0.0-rc.3
+(`/providers`, `/react`). `LaunchpadSDKConfig.walletProvider`, `setWalletProvider` and
+`SignatureAuth` take core's `WalletProvider`; a core `PrivateKeyProvider` still gives the SDK's
+services their key.
+
+The bridge moved to `@gala-chain/gala-core-sdk` 1.0.0-rc.3 (`/bridge`): `BridgeService`, the
+Ethereum and Solana strategies, `GalaConnectClient`, the bridgeable and wrappable token services
+(with their caches and the offset pagination), `WrapService`, the bridge constants and types, and
+`createSolanaWallet`. `src/bridge/` and those services are gone from launchpad-sdk; the SDK's
+bridge, balance, token-list and wrap methods build core's services (from the SDK's wallet, its
+native signer and its DEX API client) and keep their names. The bridge-out signed payloads are
+byte-identical (golden vectors, unchanged); every GalaConnect request, Ethereum and Solana
+transaction, token-list read and wrap request replays the recorded vectors, and
+`LaunchpadSDK.wrapToken` sends exactly the recorded wrap. `/native` is 337,915 bytes (was 403,450).
+
+#### Breaking (the moves)
+
+- **The bridge is gala-core-sdk's.** Every bridge export of the browser and node entries is
+  REMOVED; import it from `@gala-chain/gala-core-sdk/bridge` (same name unless listed):
+
+  | Was (launchpad-sdk) | Now (`@gala-chain/gala-core-sdk/bridge`) |
+  | --- | --- |
+  | `BaseBridgeStrategy`, `EthereumBridgeStrategy`, `SolanaBridgeStrategy`, `GalaConnectClient`, `BridgeStatusCode`, the constants (`CHAIN_IDS`, `GALACHAIN_CHANNELS`, `ETHEREUM_TOKENS_PROD` / `_STAGE`, `DEFAULT_SOLANA_TOKENS`, `ERC20_ABI`, `BRIDGE_CONTRACT_ABI`, ...), the EIP-712 constants, the token math (`toBaseUnits`, `fromBaseUnits`, `formatTokenAmount`, `compareAmounts`), `stripHexPrefix`, and every bridge, bridgeable-token and wrappable-token type | the same name |
+  | `BRIDGE_TOKEN_METADATA` | `STATIC_TOKEN_METADATA` |
+  | `BridgeRateLimiter` | `RateLimiter` |
+  | `DEFAULT_ETHEREUM_TOKENS` (deprecated alias) | `ETHEREUM_TOKENS_PROD` |
+  | `GalaConnectHttpError` | `GalaSDKError` with code `GALACONNECT_HTTP_ERROR` (`error.status`, `params.serverMessage`) |
+  | `createSolanaWallet`, `GeneratedSolanaWallet` | the same name (it was in the browser and node entries) |
+  | `WrapUnwrapStatus`, `WrapUnwrapStatusResult` | removed: a wrap resolves only once completed |
+
+  `BridgeService`, `BridgeableTokenService`, `WrappableTokenService` and `WrapService`, which
+  launchpad-sdk did not export, are exported there too.
+- **Bridge and wrap failures are typed `GalaSDKError`s** (`isGalaError(error, code)`), not
+  `ValidationError` / `NetworkError` / `TransactionError` / `GalaConnectHttpError` or a text:
+  `INVALID_BRIDGE_AMOUNT`, `INVALID_WALLET_ADDRESS`, `INVALID_TOKEN_REFERENCE`,
+  `UNSUPPORTED_BRIDGE_TOKEN`, `BRIDGE_NOT_CONFIGURED`, `INVALID_BRIDGE_OPTION`,
+  `INSUFFICIENT_BRIDGE_BALANCE`, `GALACONNECT_HTTP_ERROR`, `BRIDGE_REQUEST_REJECTED`,
+  `BRIDGE_RESPONSE_INVALID`, `BRIDGE_READ_RESPONSE_INVALID`, `BRIDGE_TOKEN_NOT_FOUND`,
+  `TOKEN_NOT_WRAPPABLE`, `INVALID_WRAP_DIRECTION`, `BRIDGE_CHAIN_READ_FAILED`, and, once something
+  may have moved (never repeat it), `BRIDGE_WRITE_OUTCOME_UNKNOWN`, `BRIDGE_OUT_OUTCOME_UNKNOWN`
+  (with the bridge request id and the `uniqueKey`), `BRIDGE_DEPOSIT_OUTCOME_UNKNOWN`,
+  `BRIDGE_STATUS_TIMEOUT`.
+- **`wrapToken` / `unwrapToken` throw instead of returning `success: false`**: `WrapUnwrapResult`
+  is the completed result (`success: true`, `transactionId` and `completedAt` always set; `error`
+  and `fee` removed). Their options have no `memo` (it was never sent). **`getWrapStatus` is
+  REMOVED** (it always answered "completed" for any id).
+- **`getBridgeStatus(hash)`** takes no chain hint (one GalaConnect read answers for either chain);
+  **`estimateBridgeFee`** takes no `amount` (the fee never depended on it).
+- Behaviour on the way: a GalaConnect write is sent again only after a 429 (a 5xx or a failure in
+  transit may have been applied: outcome unknown); an `eth|0x...` recipient is accepted; the
+  caller's own input (token id, amount, recipient, an unconfigured chain) is refused before any
+  read; a malformed RPC URL, contract, wallet address or program id option is refused when the
+  service is built.
+- `bs58` and `json-stringify-deterministic` are no longer dependencies (nor, with the 9.0 cut above,
+  `@solana/web3.js` and `@solana/spl-token`: core's `/bridge` loads them, at the first bridge
+  call). `LaunchpadSDK`'s own
+  declarations need no Node types (a consumer of it compiles with TypeScript 6 and 7 without
+  them); an app that imports `/bridge` types naming `@solana/web3.js` (e.g. `BridgeServiceConfig`)
+  needs Node's types, since `@solana/web3.js`'s declarations import `http` / `https`.
+
+- **`@gala-chain/launchpad-sdk/wallet` and `@gala-chain/launchpad-sdk/react` are REMOVED**, and so
+  are the wallet exports of the browser entry. Import from core instead (same names unless listed):
+
+  | Was (launchpad-sdk) | Now (gala-core-sdk) |
+  | --- | --- |
+  | `/wallet` and the browser entry: `PrivateKeyProvider`, `ExternalWalletProvider`, `GalaWalletProvider`, `detectWallets`, `getWalletByRdns`, `hasAnyWallet`, `isWalletAvailable`, `subscribeToWalletChanges`, `getInjectedEip1193Provider`, `KNOWN_WALLET_RDNS`, `createWalletProvider`, `createProviderFromEip1193`, `ensureConnected`, `getPrivateKeyIfAvailable`, `isPrivateKeyProvider`, `isExternalProvider`, `isEip1193Provider` and the types (`WalletProvider`, `Eip1193Provider`, `DetectedWallet`, ...) | `@gala-chain/gala-core-sdk/providers` |
+  | `WalletProviderError`, `WalletProviderErrorCode` | `GalaSDKError` from `@gala-chain/gala-core-sdk`, branched with `isGalaError(error, 'WALLET_CONNECTION_FAILED' \| 'WALLET_NOT_CONNECTED' \| 'SIGNING_FAILED' \| ...)` |
+  | `createProviderFromWallet(wallet)`, `walletToProvider(wallet)` | `PrivateKeyProvider.fromWallet(wallet)` |
+  | `providerToWallet(provider)` | `isPrivateKeyProvider(p) ? new Wallet(p.exportPrivateKey()) : undefined` (ethers stays the app's) |
+  | `/react`: `WalletProvider`, `WalletContext`, `useWallet`, `useWalletContext`, `useWalletConnection`, `useWalletDetection`, `useWalletAddress`, `useGalaAddress`, `useWalletProvider`, `useIsWalletConnected` and their types | `@gala-chain/gala-core-sdk/react` |
+  | `/react`'s re-exports `detectWallets`, `ExternalWalletProvider`, `KNOWN_WALLET_RDNS`, `PrivateKeyProvider`, type `WalletProviderInterface` | `@gala-chain/gala-core-sdk/providers` (`WalletProviderInterface` is `WalletProvider`) |
+
+  A custom `WalletProvider` now needs `getSigner()` (core's interface). `react` is no longer a peer
+  of launchpad-sdk (it is an optional peer of core's `/react`).
+- **The Ethereum wallet helpers are gala-core-sdk's.** `createWallet`, `getPublicKeyFromPrivateKey`,
+  `getEthereumAddressFromPrivateKey` and the type `PublicKeyResult` are REMOVED from launchpad-sdk
+  (browser, node and `/native` entries): import them from `@gala-chain/gala-core-sdk`. Core's
+  `createWallet` returns `{ privateKey, address, galaAddress, mnemonic }` without the ethers
+  `.wallet`: `new Wallet(createWallet(input).privateKey)`. Refusals are core `GalaSDKError`s
+  (`INVALID_WALLET_INPUT`, `INVALID_PRIVATE_KEY`) instead of `ValidationError` / ethers errors; the
+  test-mode fake key (`NODE_ENV=test`) is gone. `createSolanaWallet` moved with the bridge (above).
+  `AgentConfig` builds its wallets with core's `createWallet`; its wallet type is exported as
+  `AgentWallet` (core's wallet plus the ethers `wallet`). The internal `WalletUtils` is gone.
+
+- **The token-class and hold types are gala-core-sdk's.** `fetchTokenClassesWithSupply` returns
+  `GalaChainTokenClass[]` (was `TokenClassWithSupply`, whose `authorities` were typed as objects:
+  GalaChain sends user refs, strings) and `fetchTokenDetails` returns `GalaChainTokenDetails` (was
+  launchpad's `GalaChainTokenDetails`, whose `chatEnabled` was never set: a token's chat status is
+  `getTokenConfig(tokenName).chatEnabled`). A hold in `TokenBalanceResult` / `LockedBalanceResult`
+  is `GalaChainTokenHold` (`name` and `vestingPeriodStart` are optional, as GalaChain stores them).
+  Removed exports: `TokenClassWithSupply`, `TokenHold`, the zod `tokenHoldSchema`; import the types
+  from `@gala-chain/gala-core-sdk`. A token class carries GalaChain's documented fields only (an
+  undocumented field is no longer passed on).
+- **`TokenClassKey` and `TokenInstanceKey` REMOVED**: every signature uses gala-core-sdk's
+  `GalaChainTokenClassKey` / `GalaChainTokenInstanceKey` (same four fields, plus `instance`), so
+  import those from `@gala-chain/gala-core-sdk`. `TokenId` stays (`string | GalaChainTokenClassKey
+  | GalaChainTokenInstanceKey`). The bridge's `isTokenClassKey` export is removed: use core's
+  `isTokenClassKey` (the same check: four non-empty strings).
+- `ENVIRONMENT_URLS` takes `gatewayBaseUrl` and `dexApiBaseUrl` from core's
+  `GALA_CHAIN_ENVIRONMENTS` (same URLs); `Environment` is core's `GalaChainEnv` (`'prod' | 'stage'`).
+- **The DEX is gswap-sdk's, not launchpad-sdk's.** launchpad-sdk no longer depends on
+  `@gala-chain/gswap-sdk` (product SDKs never import each other). Removed: `sdk.dex` (the `GSwap`
+  client) and the `GSwap` re-export; the swap-backend reads `fetchAllDexSeasons`,
+  `fetchCurrentDexSeason`, `fetchDexLeaderboardBySeasonId`, `fetchCurrentDexLeaderboard`,
+  `fetchDexAggregatedVolumeSummary` and the pool poller `onDexPoolCreation`; the types `DexSeason`,
+  `LeaderboardEntry`, `LeaderboardResult`, `MasteryTitle`, `DexAggregatedVolumeSummary`. Migration:
+
+  ```typescript
+  import { PrivateKeySigner } from '@gala-chain/gala-core-sdk';
+  import { GSwap } from '@gala-chain/gswap-sdk';
+
+  const gSwap = new GSwap({ env, signer: new PrivateKeySigner(key), walletAddress: sdk.getAddress() });
+  // sdk.dex.quoting / swaps / pools / positions / symbols / assets -> gSwap.quoting / swaps / ...
+  // sdk.fetchAllDexSeasons()               -> gSwap.leaderboard.getSeasons()
+  // sdk.fetchCurrentDexSeason()            -> gSwap.leaderboard.getCurrentSeason()
+  // sdk.fetchDexLeaderboardBySeasonId(id)  -> gSwap.leaderboard.getLeaderboard(id)  ({ seasonId, entries })
+  // sdk.fetchCurrentDexLeaderboard()       -> gSwap.leaderboard.getCurrentLeaderboard()
+  // sdk.fetchDexAggregatedVolumeSummary()  -> gSwap.market.getVolumeSummary()       (8 fields)
+  // sdk.onDexPoolCreation(cb, { minTVL })  -> gSwap.pools.watchNewPools(cb, { minTvl })
+  ```
+
+  The gswap reads follow the backend's real answers: an answer of another shape is an error, not
+  `[]`; an unusable row is skipped (reported to `onInvalidEntry`), not filled with `''` / `0`; a
+  leaderboard has no `totalEntries` (`entries.length`) and a wallet without an XP breakdown has
+  `totalXp: null` (was `'0'`). `sdk.dex` was also never rebuilt by `setWallet` (it kept the first
+  wallet's signer): an app's own `GSwap` is built from the signer it means.
+  (The price reads went with the 9.0 cut above: only `fetchTokenPrice({ tokenName })` stays.)
+
+- **`sdk.tokens` and `TokenWrites` REMOVED**, with the types `ChainResult`, `TransferInput`,
+  `LockInput`, `TokenAmountInput` and `TokenIdentifier`. They were a second implementation of the
+  same writes. Migration:
+
+  ```typescript
+  // Removed
+  const result = await sdk.tokens.transfer({ to, tokenClassKey: 'GALA|Unit|none|none', quantity: '1' });
+
+  // Now (the SDK's wallet, or a { signer, walletAddress } SDK)
+  const { transactionId, blockNumber } = await sdk.transferToken({ to, tokenId: 'GALA|Unit|none|none', amount: '1' });
+  // sdk.tokens.burn / lock / unlock -> sdk.burnTokens / lockTokens / unlockTokens({ tokens: [...] })
+  ```
+
+  What the services do not take that `sdk.tokens` did: a `client|` or `eth|0x...` recipient (spell
+  an Ethereum recipient `eth|<40 hex>` or `0x<40 hex>`), any `uniqueKey` (transfer keys keep the
+  `galaswap-operation-` / `galaconnect-operation-` prefix rule), a `$`-joined `tokenId`. For
+  those, use `GatewayWrites` from `@gala-chain/gala-core-sdk` directly.
+
+#### Added
+
+- An SDK configured with `{ signer, walletAddress }` (no `wallet`) can make token writes through
+  the five methods: signed by that signer and made as the declared identity (an `eth|` account or
+  a `client|` alias). With a `wallet` nothing changed.
+- `LockTokensResult`, `UnlockTokensResult` and `BurnTokensResult` carry the gateway's
+  `x-transaction-id` as `transactionId` (preferred over a `Data` item's id) and `blockNumber`
+  from `x-block-number`, like the transfer receipts.
+
+#### Changed
+
+- Auto-generated `uniqueKey`s are `galaconnect-operation-<uuid v4>` (58 characters, CSPRNG) instead
+  of `galaconnect-operation-<ms>_<26 hex>` (62). An empty `uniqueKey` means "none" (a key is
+  minted); it used to be signed as `""` and refused by the chain.
+- A caller's `uniqueKey` on `lockTokens` / `unlockTokens` / `burnTokens` (never checked before), and
+  one with characters outside `A-Za-z0-9._:-` on a transfer, is refused before signing.
+- Quantities must be plain decimal strings (no exponent, hex or spaces); they are still signed as
+  written, never scaled.
+- A pipe `tokenId` with a non-decimal fifth part (`Token|Unit|X|client|launchpad`, read as instance
+  `launchpad`) or a `TokenInstanceKey` with a non-decimal `instance` is refused before signing
+  instead of being signed as a different token.
+- Token writes go through the SDK's gateway `HttpClient` (axios, the `Sign` header) as the five
+  methods always did; `config.httpRequestor`, which `sdk.tokens` used, is not used for them (it
+  still serves the bundler path). An app that must send token writes through its own
+  requestor uses core's `GatewayWrites` (`httpRequestor` option).
+- `setWallet` / `setWalletProvider` now rebuild the token-write services, so a transfer, burn,
+  lock or unlock signs as the new wallet (before, the services kept signing as the wallet the SDK
+  was constructed with); a declared `{ signer, walletAddress }` identity no longer applies once the
+  wallet changes.
+- A refusal of the core write before anything is sent maps to the service's error class
+  (`SIGNING_FAILED` -> `SIGNATURE_FAILED`, a token reference -> `TOKEN_NOT_FOUND`, a quantity ->
+  `INVALID_AMOUNT`, others -> the validation type).
+
+#### Fixed (wallet changes)
+
+- After `setWallet` / `setWalletProvider` nothing signs as, or sends from, the previous wallet:
+  the bundle trades (`buyTokens`, `sellTokens`) are rebuilt for the new wallet (they kept the
+  construction wallet, so an SDK started read-only could never trade), and the bridge service, the
+  wrap service and the GalaConnect client (built at first use with that wallet's address and key,
+  then kept forever) are dropped and rebuilt for the new wallet at their next use.
+- An identity declared at construction (`walletAddress`, `galaChainAddress`, e.g. a `client|`
+  alias) named the construction key and is dropped on a wallet change: `getAddress()` was still
+  the old one, so the rebuilt services would have paired the new key with the old identity.
+- `SignatureAuth.setWalletProvider` with a key-holding provider (`PrivateKeyProvider`) knows the
+  address at once, as `setWallet` does (the synchronous getters threw until `cacheAddress()`); a
+  wallet-backed provider still needs `cacheAddress()` and never reports the previous account.
+
+#### Fixed (gateway reads)
+
+- `fetchGalaBalance` and `fetchTokenBalance` (tokenId and MUSIC/GMUSIC routes) work against the
+  real gateway again: their `FetchBalances` body carried `instance: "0"`, which mainnet and testnet
+  refuse with HTTP 400 ("whitelistValidation: property instance should not exist", recorded
+  2026-10-13), so every such call threw a `NetworkError`. The body is now the chain DTO
+  (`owner, collection, category, type, additionalKey`).
+- A balance record of another owner than the one asked for is never reported as theirs (the read
+  answers `null`); a missing owner is refused instead of reading every owner's balances.
+- `availableQuantity` / `lockedQuantity` / `inUseQuantity` are never in exponent form
+  (`0.00000001`, not `1e-8`).
+- `fetchNftCollections`, `isNftCollectionAvailable`, `fetchNftTokenClasses` and `fetchNftBalances`
+  read GalaChain (`FetchNftCollectionAuthorizationsWithPagination`,
+  `FetchTokenClassesWithPagination`, `FetchBalances`, page by page and bounded); they were
+  placeholders that always answered `[]` / `true`. `isNftCollectionAvailable` throws when the read
+  fails (never "available"), so `claimNftCollection` refuses a name that is already claimed. The
+  NFT writes (`claimNftCollection`, `createNftTokenClass`, `mintNft`) still do not reach GalaChain:
+  they return a locally made transaction id with status `pending`.
+
+#### Fixed (price history; these reads are now the MCP server's, on gswap-sdk, which keeps the fixes)
+
+- `fetchAllPriceHistory` reads the series once. It paged it through `fetchPriceHistory` with the
+  page NUMBER as the offset (0, 1, 2, ... with 50 per page), so a series over 50 points was
+  refetched in full per page (a 120-point series: about 100 requests) and came back with
+  overlapping, repeated snapshots; a series that changed between two requests shifted the pages.
+  A caller's `offset` / `limit` do not apply to it.
+- `fetchPriceHistory` refuses a `limit` or `pageSize` outside 1-50 and a negative or fractional
+  `offset` before any request (`ValidationError`). A `limit` of 0 used to answer `page: NaN`,
+  `totalPages: Infinity` (JSON `null`).
+
+#### Changed (gateway reads)
+
+- A `FetchBalances` / `FetchTokenClasses` answer that is not GalaChain's (a numeric quantity, a hold
+  or class missing its fields) is refused whole: a balance is then `null` (as for any unusable
+  answer), a token class a `NetworkError`. A token-class answer without the class asked for is a
+  `NetworkError` ("Token not found on GalaChain", 404) instead of returning another class.
+  `fetchTokenClassesWithSupply` answers one class per key in the order asked (1 to 1000 keys).
+
+#### Removed (internal)
+
+- `api/dto/{TransferTokenDto,BurnTokensDto,LockTokenDto,UnlockTokenDto}` (and with them
+  `@gala-chain/api`'s `ChainCallDTO` on these paths), `utils/token-instance-key.ts`.
+- `GalaChainBalanceService`'s `sumHoldQuantities` / `filterHolds` / `calculateAvailableQuantity`
+  (core totals the holds), the `GalaChainTokenBalance` / `InternalGalaChainFetchBalancesResponse` /
+  `InternalFetchTokenClassesWithSupplyResponse` types, `BalanceQueryParams.instance`, and
+  `@gala-chain/api`'s `TokenClass` on the token-class paths.
+- Dead code: `utils/token-parser` `parseToken` (no caller), `isDelimited`, `isValidTokenFormat`,
+  `isPlainTokenSymbol` and its `isTokenClassKey`; `delimiter-parser` `validateTokenObject` (only
+  `parseToken` used it); `tokenNormalizer`'s `isTokenClassKeyStrict` re-export, `isTokenInstanceKey`
+  and `isTokenIdString`; `unique-key-generator` `generateOperationKey` (no caller; its keys held a
+  `|` and exceeded 64 characters); the unimported modules `types/token.types.ts` and
+  `types/galachain-api.types.ts` (a third and fourth `TokenClassKey` / `isTokenClassKey`).
+- The GSwap error wrappers `GSwapQuoteError`, `GSwapSwapError`, `GSwapPoolError`,
+  `GSwapAssetError`, `GSwapPositionError`, `DexQuoteError`, `DexPoolNotFoundError` and
+  `handleGSwapErrorGeneric` (not exported, never thrown: gswap-sdk's `GSwapSDKError` is the DEX
+  error); `DexService`'s season, leaderboard and volume reads; `scripts/stage-verify-dex-reads.ts`
+  (`verify:stage-dex-reads`, which checked `sdk.dex`).
+- `@gala-chain/gswap-sdk` was then a devDependency only (the examples and the live stage test); with
+  the 9.0 cut above it is no dependency of any kind.
+
 ## 6.0.0
 
 ### BREAKING CHANGES