@parity/product-sdk 0.0.0-dev.312.0 → 0.0.0-dev.329.1

package/src/individuality/contract.test.ts

@@ -31,10 +31,32 @@
  * `@ts-expect-error` would report as unused and this file would fail.
  */
 import type { getChainAPI } from "@parity/product-sdk-chain-client";
-import type { RingVRFProof as HostRingVRFProof } from "@parity/product-sdk-host";
 import type {
+    RingLocation as HostRingLocation,
+    RingVRFProof as HostRingVRFProof,
+    VrfSignature as HostVrfSignature,
+    VrfTranscriptItem as HostVrfTranscriptItem,
+} from "@parity/product-sdk-host";
+import type {
+    AirdropChain,
+    ClaimChain,
     ConsumersChain,
+    GameChain,
+    GamePlayersChain,
     IndividualityChain,
+    LegacySuffixChain,
+    LiteAliasBindChain,
+    LiteSignUpChain,
+    NetworkSuffixChain,
+    PapiIndividualityChain,
+    PrizeStatusChain,
+    RegisterChain,
+    RegistrationEligibilityChain,
+    RingLocation as SdkRingLocation,
+    ScoreContextChain,
+    SignUpChain,
+    AccountVrfSignature,
+    VrfTranscriptItem as IndividualityVrfTranscriptItem,
     RingVRFProof as AsPersonRingVRFProof,
 } from "@parity/product-sdk-individuality";
 import { expect, test } from "vitest";
@@ -45,17 +67,108 @@ type Assert<T extends true> = T;
 
 type PaseoClient = Awaited<ReturnType<typeof getChainAPI<"paseo">>>;
 type DevnetClient = Awaited<ReturnType<typeof getChainAPI<"devnet">>>;
+// Previewnet runs a Paseo runtime kept a step ahead of paseo-next-v2, so it
+// satisfies every individuality contract paseo does — including the game
+// surface devnet predates. These assertions are a compile-time guard on the
+// re-added descriptor. The only shape drift is `PeopleLite.LitePeople`'s method
+// enum gaining a `Fee` variant, which the contracts type as `unknown` and absorb.
+type PreviewnetClient = Awaited<ReturnType<typeof getChainAPI<"previewnet">>>;
 
-// These four aliases are the test. Each fails to typecheck if its condition
+// These aliases are the test. Each fails to typecheck if its condition
 // breaks, so they need no export and no runtime reference.
 type PaseoSatisfiesContract = Assert<PaseoClient extends IndividualityChain ? true : false>;
 type DevnetSatisfiesContract = Assert<DevnetClient extends IndividualityChain ? true : false>;
+type PreviewnetSatisfiesContract = Assert<
+    PreviewnetClient extends IndividualityChain ? true : false
+>;
 
 // `ConsumersChain` needs this more than the batch contract does: its value shape
 // was derived from the pallet and the codegen rather than read off the emitted
 // descriptor, so these two lines are what make that derivation a checked fact.
 type PaseoSatisfiesConsumers = Assert<PaseoClient extends ConsumersChain ? true : false>;
 type DevnetSatisfiesConsumers = Assert<DevnetClient extends ConsumersChain ? true : false>;
+type PreviewnetSatisfiesConsumers = Assert<PreviewnetClient extends ConsumersChain ? true : false>;
+
+// Separate from the personhood contract: reading draws needs neither `Resources`
+// nor `PeopleLite`. Both chains satisfy it, which is weaker than it looks — devnet's
+// event-id base is 28 bytes to paseo's 27, and `SizedHex<N>` erases `N`, so only the
+// length check in `airdrop-ids.ts` catches that.
+type PaseoSatisfiesAirdropContract = Assert<PaseoClient extends AirdropChain ? true : false>;
+type DevnetSatisfiesAirdropContract = Assert<DevnetClient extends AirdropChain ? true : false>;
+type PreviewnetSatisfiesAirdropContract = Assert<
+    PreviewnetClient extends AirdropChain ? true : false
+>;
+
+// Same again for the current-game contract, which shares no entry with either of
+// the other two — but paseo only, and that asymmetry is the point.
+type PaseoSatisfiesGameContract = Assert<PaseoClient extends GameChain ? true : false>;
+// Previewnet is ahead of paseo, so it carries the game surface too (unlike devnet).
+type PreviewnetSatisfiesGameContract = Assert<PreviewnetClient extends GameChain ? true : false>;
+
+// Devnet's metadata predates the multi-airdrop game work — the 28-byte base above is
+// one symptom, `game-types.ts` lists the rest — so the game surface is paseo-only.
+// Asserted negatively on purpose: a devnet re-pin breaks this line, which is the
+// prompt to flip it positive and check the read against it.
+type DevnetPredatesTheGameContract = Assert<DevnetClient extends GameChain ? false : true>;
+
+// `GamePlayersChain` is the opt-in half of the game read (`players`), typed
+// separately so a caller who never asks about a player keeps the narrower
+// contract. Both game-capable chains carry `Game.Players`.
+type PaseoSatisfiesPlayersContract = Assert<PaseoClient extends GamePlayersChain ? true : false>;
+type PreviewnetSatisfiesPlayersContract = Assert<
+    PreviewnetClient extends GamePlayersChain ? true : false
+>;
+
+// `fromPapi` hands a caller's own typed API to the reads; it must land exactly
+// where the chain-client shape puts it, or every contract above would be
+// satisfied by `getChainAPI` and none by a self-connected product.
+type FromPapiSatisfiesContracts = Assert<
+    PapiIndividualityChain<PaseoClient["individuality"]> extends IndividualityChain &
+        AirdropChain &
+        GameChain &
+        GamePlayersChain &
+        ScoreContextChain &
+        SignUpChain &
+        LiteSignUpChain
+        ? true
+        : false
+>;
+
+// Storage is the only way either chain resolves a suffix since the re-pin, so the
+// bring-your-own-client path needs it asserted too.
+type FromPapiSatisfiesTheSuffixStorage = Assert<
+    PapiIndividualityChain<
+        PaseoClient["individuality"],
+        PaseoClient["raw"]["individuality"]
+    > extends NetworkSuffixChain
+        ? true
+        : false
+>;
+
+type PaseoSatisfiesScoreContext = Assert<PaseoClient extends ScoreContextChain ? true : false>;
+type DevnetSatisfiesScoreContext = Assert<DevnetClient extends ScoreContextChain ? true : false>;
+type PreviewnetSatisfiesScoreContext = Assert<
+    PreviewnetClient extends ScoreContextChain ? true : false
+>;
+
+// The suffix moved from a constant to storage upstream, and the 2026-09-03 re-pin
+// brought that to both live chains. Devnet still predates it, so it holds the old
+// shape and is the one asserted negatively now.
+type PreviewnetPredatesTheLegacySuffix = Assert<
+    PreviewnetClient extends LegacySuffixChain ? false : true
+>;
+type PaseoPredatesTheLegacySuffix = Assert<PaseoClient extends LegacySuffixChain ? false : true>;
+type DevnetPredatesTheLegacySuffix = Assert<DevnetClient extends LegacySuffixChain ? false : true>;
+type PreviewnetHasSuffixStorage = Assert<
+    PreviewnetClient extends NetworkSuffixChain ? true : false
+>;
+type PaseoHasSuffixStorage = Assert<PaseoClient extends NetworkSuffixChain ? true : false>;
+type DevnetHasNoSuffixStorage = Assert<DevnetClient extends NetworkSuffixChain ? false : true>;
+
+// The two are declared separately, so a rename on either side would go
+// unnoticed anywhere but here.
+type LocalRingLocationFitsHost = Assert<SdkRingLocation extends HostRingLocation ? true : false>;
+type HostRingLocationFitsLocal = Assert<HostRingLocation extends SdkRingLocation ? true : false>;
 
 // Negative control, kept type-only so it emits no runtime code. If
 // `IndividualityChain` ever stopped constraining, this flips to `false` and the
@@ -68,6 +181,72 @@ type ClientWithoutIndividuality = {
 type RejectsBogusClient = Assert<
     ClientWithoutIndividuality extends IndividualityChain ? false : true
 >;
+type RejectsBogusAirdropClient = Assert<
+    ClientWithoutIndividuality extends AirdropChain ? false : true
+>;
+type RejectsBogusGameClient = Assert<ClientWithoutIndividuality extends GameChain ? false : true>;
+type RejectsBogusPlayersClient = Assert<
+    ClientWithoutIndividuality extends GamePlayersChain ? false : true
+>;
+
+// `Game.Game` being optional is what makes "between games" representable at all,
+// and `GameIndex` / `GameSchedules` being `ValueQuery` is what lets the read treat
+// them as always answering. The structural contract pins the latter two by typing
+// them non-optional; this pins the first, which no assignability check would
+// catch — a suddenly-required `Game` would still satisfy an optional contract.
+type GameStorage = PaseoClient["individuality"]["query"]["Game"];
+type GameValue = Awaited<ReturnType<GameStorage["Game"]["getValue"]>>;
+type GameIsOptional = Assert<undefined extends GameValue ? true : false>;
+// Negative control: `GameIndex` is `ValueQuery`, so it must *not* admit undefined.
+type GameIndexValue = Awaited<ReturnType<GameStorage["GameIndex"]["getValue"]>>;
+type GameIndexIsNotOptional = Assert<undefined extends GameIndexValue ? false : true>;
+
+// The event id is derived from a runtime constant rather than a storage entry, so
+// the constant has to exist and still be a plain string. Its *width* cannot be
+// asserted here: PAPI's `SizedHex<N>` is `string & { __hexString?: N | unknown }`,
+// and the `| unknown` collapses every width to the same type, so `SizedHex<32>`
+// and `SizedHex<27>` are mutually assignable and any such assertion would pass
+// vacuously. The 27-byte expectation is enforced at runtime instead, by the
+// length check in `airdrop-ids.ts` and the pinned vectors beside it.
+type GameConstants = PaseoClient["individuality"]["constants"]["Game"];
+type EventIdBaseExists = Assert<"airdrop_event_id_base" extends keyof GameConstants ? true : false>;
+type AirdropEventIdBase = Awaited<ReturnType<GameConstants["airdrop_event_id_base"]>>;
+type EventIdBaseIsAString = Assert<AirdropEventIdBase extends string ? true : false>;
+
+// The composed prize-status read spans both pallets, so it is the intersection
+// that has to hold — and on paseo only, since it inherits `GameChain`.
+type PaseoSatisfiesPrizeStatusContract = Assert<
+    PaseoClient extends PrizeStatusChain ? true : false
+>;
+type PreviewnetSatisfiesPrizeStatusContract = Assert<
+    PreviewnetClient extends PrizeStatusChain ? true : false
+>;
+type DevnetPredatesThePrizeStatusContract = Assert<
+    DevnetClient extends PrizeStatusChain ? false : true
+>;
+
+// `Registrations` is keyed by the entropy slot with the entry as its *value*, so
+// `readDrawRegistration` can only work by scanning the event's prefix. Pinning the
+// arity here is what would catch a descriptor regeneration that added a reverse
+// index and made the scan unnecessary.
+type RegistrationsEntries = Awaited<
+    ReturnType<PaseoClient["individuality"]["query"]["Airdrop"]["Registrations"]["getEntries"]>
+>;
+type RegistrationsKeyIsEventIdAndSlot = Assert<
+    RegistrationsEntries[number]["keyArgs"] extends [unknown, unknown] ? true : false
+>;
+
+// `Winners` is a double map keyed by the registration entry, which is what makes
+// "did I win" a point lookup instead of a scan of every winner. If a descriptor
+// regeneration ever collapsed it to a single key, the read layer would silently
+// need rewriting, so the arity is pinned.
+type WinnersKey = Parameters<
+    PaseoClient["individuality"]["query"]["Airdrop"]["Winners"]["getValue"]
+>;
+type WinnersTakesTwoKeys = Assert<
+    WinnersKey extends [unknown, unknown, ...unknown[]] ? true : false
+>;
+
 type RejectsBogusConsumersClient = Assert<
     ClientWithoutIndividuality extends ConsumersChain ? false : true
 >;
@@ -128,6 +307,251 @@ type SignUpWithAliasTakesTheDocumentedArgs = Assert<
 type SignUpArgsWithoutSig = Pick<SignUpWithAliasArgs, "identifier_key" | "statement_account">;
 type RejectsSignUpArgsMissingSig = Assert<"sig" extends keyof SignUpArgsWithoutSig ? false : true>;
 
+// The claim is the one contract here that touches `tx` as well as storage. Paseo
+// only, like the game surface it composes with.
+type PaseoSatisfiesClaimContract = Assert<PaseoClient extends ClaimChain ? true : false>;
+type PreviewnetSatisfiesClaimContract = Assert<PreviewnetClient extends ClaimChain ? true : false>;
+type RejectsBogusClaimClient = Assert<ClientWithoutIndividuality extends ClaimChain ? false : true>;
+
+// `claim_airdrop`'s three arguments, pinned by name. `ClaimChain` types them
+// structurally, and PAPI encodes whatever object it is handed — so a renamed field
+// would encode as `undefined` and fail on chain with nothing local to point at it.
+type ClaimAirdropArgs = Parameters<GameTx["claim_airdrop"]>[0];
+type ClaimAirdropTakesTheDocumentedArgs = Assert<
+    "game_index" extends keyof ClaimAirdropArgs
+        ? "airdrop_index" extends keyof ClaimAirdropArgs
+            ? "beneficiary" extends keyof ClaimAirdropArgs
+                ? true
+                : false
+            : false
+        : false
+>;
+
+// Game sign-up.
+type PaseoSatisfiesSignUpContract = Assert<PaseoClient extends SignUpChain ? true : false>;
+type RejectsBogusSignUpClient = Assert<
+    ClientWithoutIndividuality extends SignUpChain ? false : true
+>;
+
+// `SignUpChain` alone does not reject devnet and cannot: a `tx` argument is
+// checked contravariantly and excess-property checking does not apply between
+// named types, so an interface naming `airdrops` is satisfied by devnet's call,
+// which has only `airdrop`. `identifier_key` does not separate them either, since
+// `SizedHex<N>`'s brand is optional. Assert on the intersection the read takes,
+// where `GameChain` is the half that rejects devnet.
+type PaseoSatisfiesSignUpRead = Assert<PaseoClient extends GameChain & SignUpChain ? true : false>;
+type PreviewnetSatisfiesSignUpRead = Assert<
+    PreviewnetClient extends GameChain & SignUpChain ? true : false
+>;
+type DevnetPredatesTheSignUpRead = Assert<
+    DevnetClient extends GameChain & SignUpChain ? false : true
+>;
+
+// The divergence itself: devnet's argument is `airdrop`, so `signUpWithAccountTx`
+// emitting `airdrops` would encode as `undefined` and enter no draw at all.
+type DevnetGameTx = DevnetClient["individuality"]["tx"]["Game"];
+type DevnetSignUpArgs = Parameters<DevnetGameTx["sign_up_with_account"]>[0];
+type DevnetHasNoAirdropsArg = Assert<"airdrops" extends keyof DevnetSignUpArgs ? false : true>;
+type DevnetHasTheSingularArg = Assert<"airdrop" extends keyof DevnetSignUpArgs ? true : false>;
+
+// Pinned by name for the same reason `claim_airdrop`'s are: PAPI encodes the
+// object it is handed, so a renamed field silently encodes as `undefined`.
+type SignUpWithAccountArgs = Parameters<GameTx["sign_up_with_account"]>[0];
+type SignUpWithAccountTakesTheDocumentedArgs = Assert<
+    "identifier_key" extends keyof SignUpWithAccountArgs
+        ? "airdrops" extends keyof SignUpWithAccountArgs
+            ? true
+            : false
+        : false
+>;
+
+// `None` is how a player enters no draw, and the only form a recognized player
+// can use at all.
+type AirdropsArg = SignUpWithAccountArgs["airdrops"];
+type AirdropsIsOptional = Assert<undefined extends AirdropsArg ? true : false>;
+
+// Extracted from the enum rather than restated, so a renamed field fails here
+// instead of on chain.
+type AccountVrfs = Extract<NonNullable<AirdropsArg>, { type: "Account" }>["value"][number];
+type AccountVrfHasPreOutputAndProof = Assert<
+    "pre_output" extends keyof AccountVrfs
+        ? "proof" extends keyof AccountVrfs
+            ? true
+            : false
+        : false
+>;
+
+// The VRF types are local copies of the host's, declared here for the same reason
+// `AsPersonRingVRFProof` is: so the package keeps no host dependency. Those host
+// types are mapped straight off truapi's wire types, so a rename there changes them
+// with no line of this repo touched, and the break would land as a runtime
+// TypeError rather than a failed typecheck.
+type HostVrfSignatureSatisfiesLocal = Assert<
+    HostVrfSignature extends AccountVrfSignature ? true : false
+>;
+type HostVrfItemSatisfiesLocal = Assert<
+    HostVrfTranscriptItem extends IndividualityVrfTranscriptItem ? true : false
+>;
+
+// Negative controls, so the two above cannot pass vacuously.
+type RejectsSignatureMissingProof = Assert<
+    { preOutput: Uint8Array } extends AccountVrfSignature ? false : true
+>;
+type RejectsItemMissingValue = Assert<
+    { label: Uint8Array } extends IndividualityVrfTranscriptItem ? false : true
+>;
+
+// The lite sign-up surface: the alias binding, the lite-person marker, the
+// invite pin, the ring membership entry and the free sign-up call. Paseo and
+// previewnet carry all five; devnet predates `Game.LiteInvites` and the call,
+// so it is asserted negatively, like the game surface it composes with.
+type PaseoSatisfiesLiteSignUpContract = Assert<PaseoClient extends LiteSignUpChain ? true : false>;
+type PreviewnetSatisfiesLiteSignUpContract = Assert<
+    PreviewnetClient extends LiteSignUpChain ? true : false
+>;
+type DevnetPredatesTheLiteSignUpContract = Assert<
+    DevnetClient extends LiteSignUpChain ? false : true
+>;
+type RejectsBogusLiteSignUpClient = Assert<
+    ClientWithoutIndividuality extends LiteSignUpChain ? false : true
+>;
+
+// `LiteSignUpChain` alone proves nothing about what the read accepts: it takes
+// an intersection and resolves a suffix.
+type LiteSignUpReadBase = GameChain & SignUpChain & ScoreContextChain & LiteSignUpChain;
+type PaseoSatisfiesTheLiteReadWithATld = Assert<
+    PaseoClient extends LiteSignUpReadBase ? true : false
+>;
+// Both chains resolve the suffix from storage since the 2026-09-03 re-pin, so the
+// storage overload is the live path and neither can use the constant one.
+type PaseoSatisfiesTheLiteReadFromStorage = Assert<
+    PaseoClient extends LiteSignUpReadBase & NetworkSuffixChain ? true : false
+>;
+type PreviewnetSatisfiesTheLiteReadFromStorage = Assert<
+    PreviewnetClient extends LiteSignUpReadBase & NetworkSuffixChain ? true : false
+>;
+type NeitherChainHasTheLegacyConstant = Assert<
+    PaseoClient | PreviewnetClient extends LiteSignUpReadBase & LegacySuffixChain ? false : true
+>;
+type DevnetPredatesTheLiteRead = Assert<DevnetClient extends LiteSignUpReadBase ? false : true>;
+
+// Wider than the reads above: the builder assembles the extrinsic itself, so it
+// needs the chain spec and the metadata blob, not just the call.
+type PaseoSatisfiesBindContract = Assert<PaseoClient extends LiteAliasBindChain ? true : false>;
+type PreviewnetSatisfiesBindContract = Assert<
+    PreviewnetClient extends LiteAliasBindChain ? true : false
+>;
+type DevnetSatisfiesBindContract = Assert<DevnetClient extends LiteAliasBindChain ? true : false>;
+type FromPapiSatisfiesBindContract = Assert<
+    PapiIndividualityChain<
+        PaseoClient["individuality"],
+        PaseoClient["raw"]["individuality"]
+    > extends LiteAliasBindChain
+        ? true
+        : false
+>;
+type RejectsBogusBindClient = Assert<
+    ClientWithoutIndividuality extends LiteAliasBindChain ? false : true
+>;
+
+// Pinned by name for the same reason `sign_up_with_account`'s are: PAPI encodes
+// the object it is handed, so a renamed field silently encodes as `undefined` —
+// and `account` here is a call argument, not implied by the signer.
+type LiteInviteArgs = Parameters<GameTx["sign_up_with_account_lite_invite"]>[0];
+type LiteInviteTakesTheDocumentedArgs = Assert<
+    "account" extends keyof LiteInviteArgs
+        ? "identifier_key" extends keyof LiteInviteArgs
+            ? "airdrops" extends keyof LiteInviteArgs
+                ? true
+                : false
+            : false
+        : false
+>;
+type LiteInviteAirdropsIsOptional = Assert<
+    undefined extends LiteInviteArgs["airdrops"] ? true : false
+>;
+
+// `PeopleLite.AccountToAlias`: the three fields the lite requirement read uses.
+// The context matters as much as the alias — a binding outside the score
+// context does not satisfy the game's origin check — so it is pinned by name.
+type LiteBindingValue = NonNullable<
+    Awaited<
+        ReturnType<
+            PaseoClient["individuality"]["query"]["PeopleLite"]["AccountToAlias"]["getValue"]
+        >
+    >
+>;
+type LiteBindingHasTheDocumentedFields = Assert<
+    "revision" extends keyof LiteBindingValue
+        ? "ring" extends keyof LiteBindingValue
+            ? LiteBindingValue["ca"] extends { alias: string; context: string }
+                ? true
+                : false
+            : false
+        : false
+>;
+
+// `Members.Members` is a double map (collection id, member key), which is what
+// lets the membership check be a point read. A collapsed key would silently
+// turn the varargs call into a mistyped one, so the arity is pinned.
+type MembersKey = Parameters<
+    PaseoClient["individuality"]["query"]["Members"]["Members"]["getValue"]
+>;
+type MembersTakesTwoKeys = Assert<
+    MembersKey extends [unknown, unknown, ...unknown[]] ? true : false
+>;
+
+// `Game.Players`: the variant spelling the read keys by, and the one field it uses.
+// Sibling reads got exactly these pins.
+type PlayersEntry = PaseoClient["individuality"]["query"]["Game"]["Players"];
+type PlayersKey = Parameters<PlayersEntry["getValue"]>[0];
+type PlayersKeyIsAccountOrPerson = Assert<
+    PlayersKey extends { type: "Account" | "Person" } ? true : false
+>;
+type RejectsAliasSpelling = Assert<
+    { type: "Alias"; value: string } extends PlayersKey ? false : true
+>;
+type PlayersValue = NonNullable<Awaited<ReturnType<PlayersEntry["getValue"]>>>;
+type PlayersHasRegistered = Assert<"registered" extends keyof PlayersValue ? true : false>;
+
+type PaseoSatisfiesRegisterContract = Assert<PaseoClient extends RegisterChain ? true : false>;
+type PreviewnetSatisfiesRegisterContract = Assert<
+    PreviewnetClient extends RegisterChain ? true : false
+>;
+type DevnetSatisfiesRegisterContract = Assert<DevnetClient extends RegisterChain ? true : false>;
+type RejectsBogusRegisterClient = Assert<
+    ClientWithoutIndividuality extends RegisterChain ? false : true
+>;
+
+type PaseoSatisfiesEligibilityContract = Assert<
+    PaseoClient extends RegistrationEligibilityChain ? true : false
+>;
+type PreviewnetSatisfiesEligibilityContract = Assert<
+    PreviewnetClient extends RegistrationEligibilityChain ? true : false
+>;
+type DevnetSatisfiesEligibilityContract = Assert<
+    DevnetClient extends RegistrationEligibilityChain ? true : false
+>;
+type RejectsBogusEligibilityClient = Assert<
+    ClientWithoutIndividuality extends RegistrationEligibilityChain ? false : true
+>;
+
+// The same trap as `claim_airdrop`'s pins, and worse: `key` is an `Option`, so a
+// renamed argument encodes as `None` — the resume arm this builder never means.
+type ScoreTx = PaseoClient["individuality"]["tx"]["Score"];
+type RegisterExists = Assert<"register" extends keyof ScoreTx ? true : false>;
+type RegisterArgs = Parameters<ScoreTx["register"]>[0];
+type RegisterTakesKey = Assert<"key" extends keyof RegisterArgs ? true : false>;
+type RegisterKeyIsOptional = Assert<undefined extends RegisterArgs["key"] ? true : false>;
+
+// `ValueQuery` is what lets the read type the threshold as a plain number, and
+// `Participants` being optional is what makes "never seen" a null, not a throw.
+type ScoreStorage = PaseoClient["individuality"]["query"]["Score"];
+type ThresholdValue = Awaited<ReturnType<ScoreStorage["PersonhoodThreshold"]["getValue"]>>;
+type ThresholdIsNotOptional = Assert<undefined extends ThresholdValue ? false : true>;
+type ParticipantsValue = Awaited<ReturnType<ScoreStorage["Participants"]["getValue"]>>;
+type ParticipantsIsOptional = Assert<undefined extends ParticipantsValue ? true : false>;
+
 test("the individuality chain contract is asserted at compile time", () => {
     // The type assertions above are the test. This keeps vitest from reporting
     // the file as an empty suite.

package/src/nfts/contract.test.ts

@@ -0,0 +1,58 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Compile-time guard for the chain contract in `@parity/product-sdk-nfts`.
+ *
+ * That package types its chain parameter structurally, listing the storage
+ * entries it needs rather than naming a descriptor — same trade as
+ * `IndividualityChain`, and the same gap: a hand-written contract can drift from
+ * the real chain silently, because the package's own test doubles satisfy it by
+ * construction. See `../individuality/contract.test.ts` for why this assertion
+ * has to live in `@parity/product-sdk` to mean anything, and why it checks the
+ * sibling's built `dist` rather than its `src`.
+ *
+ * The `ItemDefs` line below is the one that earned this file. PAPI generates its
+ * key as `FixedSizeArray<2, number>` rather than the `[number, number]` tuple it
+ * gives `CollectionMetadata` and `ItemMetadata`, because the runtime's metadata
+ * declares the key type as an array. The raw storage layout is nonetheless two
+ * Twox64Concat segments — a genuine two-key map, verified against live state
+ * with `rpc.state_getKeys` — so a prefix scan by collection is sound at the
+ * protocol level. Whether PAPI's *typing* admits the one-arg `getEntries` that
+ * `NftsChain` asks for is a different question, and this is what answers it.
+ *
+ * **Paseo only, and that asymmetry is the point.** `devnet-asset-hub` carries
+ * neither `Scarcity` nor `NftClaims`, so the negative control below is not a
+ * hypothetical: it is the live state of the other supported network.
+ */
+import type { getChainAPI } from "@parity/product-sdk-chain-client";
+import type { NftsChain, NftsCreditsChain } from "@parity/product-sdk-nfts";
+import { expect, test } from "vitest";
+
+// The false branch must be `false`, not `never`. `never` is assignable to
+// `true`, so a `never` branch would make the assertion unfalsifiable.
+type Assert<T extends true> = T;
+
+type PaseoClient = Awaited<ReturnType<typeof getChainAPI<"paseo">>>;
+type DevnetClient = Awaited<ReturnType<typeof getChainAPI<"devnet">>>;
+
+// The test: this alias fails to typecheck if the contract drifts from the
+// descriptor, so it needs no export and no runtime reference.
+type PaseoSatisfiesContract = Assert<PaseoClient extends NftsChain ? true : false>;
+
+// The credits read spans both chains the preset carries, so the same client
+// has to satisfy the second contract too.
+type PaseoSatisfiesCredits = Assert<PaseoClient extends NftsCreditsChain ? true : false>;
+
+// The negative control, and a real fact about the network rather than a
+// hypothetical: devnet Asset Hub has no `Scarcity` and no `NftClaims`. If
+// `NftsChain` ever stopped constraining, this `@ts-expect-error` would report
+// as unused and the file would fail.
+// @ts-expect-error devnet Asset Hub carries neither pallet
+type DevnetLacksPallets = Assert<DevnetClient extends NftsChain ? true : false>;
+
+test("nfts chain contract holds against the paseo descriptor", () => {
+    // The assertions above are compile-time. This keeps vitest from reporting
+    // the file as having no tests, and documents that a green run means tsc
+    // accepted them.
+    expect(true).toBe(true);
+});

package/src/nfts/index.ts

@@ -0,0 +1,8 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * @parity/product-sdk/nfts
+ *
+ * Re-exports from @parity/product-sdk-nfts.
+ */
+export * from "@parity/product-sdk-nfts";

package/src/react/context.ts

@@ -28,7 +28,7 @@ export function useProductSDK(): App {
     if (!app) {
         throw new Error(
             "useProductSDK must be used within a ProductSDKProvider. " +
-                'Wrap your app with <ProductSDKProvider name="your-app">.',
+                "Wrap your app with <ProductSDKProvider>.",
         );
     }
     return app;

package/src/react/index.ts

@@ -12,7 +12,7 @@
  *
  * function App() {
  *   return (
- *     <ProductSDKProvider name="my-app">
+ *     <ProductSDKProvider>
  *       <MyApp />
  *     </ProductSDKProvider>
  *   );

package/src/react/provider.tsx

@@ -11,8 +11,8 @@ import type { App, LogLevel } from "../core/types.js";
 
 /** Props for ProductSDKProvider */
 export interface ProductSDKProviderProps {
-    /** Application name - used for storage namespacing and product account derivation */
-    name: string;
+    /** @deprecated Ignored with a warning. The host product ID supplies the app name. */
+    name?: string;
     /** Log level (default: 'info') */
     logLevel?: LogLevel;
     /** Child components */
@@ -30,7 +30,7 @@ export interface ProductSDKProviderProps {
  *
  * function App() {
  *   return (
- *     <ProductSDKProvider name="my-app" fallback={<Loading />}>
+ *     <ProductSDKProvider fallback={<Loading />}>
  *       <MyApp />
  *     </ProductSDKProvider>
  *   );

package/src/renderer/index.ts

@@ -0,0 +1,10 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Renderer trees — Pocket card faces and rendered chat bodies.
+ *
+ * Re-exports `@parity/product-sdk-renderer`.
+ *
+ * @module
+ */
+export * from "@parity/product-sdk-renderer";

package/src/testing.ts

@@ -11,7 +11,9 @@
  * @packageDocumentation
  */
 import { ProductCloudStorageError } from "@parity/product-sdk-cloud-storage";
+import type { LocalKvStore } from "@parity/product-sdk-local-storage";
 import { createFakeHostLocalStorage } from "@parity/product-sdk-local-storage/testing";
+import { createLocalStorageApi } from "./core/local-storage-api.js";
 import { err, ok, unwrapErr, unwrapOk } from "@parity/result";
 
 import type {
@@ -119,10 +121,13 @@ function makeFakeWallet(options?: FakeWalletOptions): WalletApi {
 }
 
 function makeFakeLocalStorage(): LocalStorageApi {
-    // Compose the local-storage fake; mirror createApp's adapter semantics
-    // (get normalizes "" -> null, getJSON normalizes undefined -> null).
+    // Route through the *same* `createLocalStorageApi` factory `createApp` uses,
+    // so the fake and the shipped adapter cannot drift (#344). The fake's host
+    // is adapted to a `LocalKvStore` here rather than via the async
+    // `createLocalKvStore`, so `createFakeApp` stays synchronous; the semantics
+    // (get "" -> null, getJSON undefined -> null) match `createHostBackend`.
     const host = createFakeHostLocalStorage();
-    return {
+    const kv: LocalKvStore = {
         async get(key) {
             return (await host.readString(key)) || null;
         },
@@ -132,18 +137,14 @@ function makeFakeLocalStorage(): LocalStorageApi {
         async getJSON<T>(key: string) {
             return ((await host.readJSON(key)) ?? null) as T | null;
         },
-        async setJSON<T>(key: string, value: T) {
+        async setJSON(key, value) {
             await host.writeJSON(key, value);
         },
         async remove(key) {
             await host.clear(key);
         },
-        async clear() {
-            // Unlike the production adapter (a no-op in container mode), the fake
-            // actually empties, so tests get real isolation.
-            host.reset();
-        },
     };
+    return createLocalStorageApi(kv);
 }
 
 function makeFakeCloudStorage(): CloudStorageApi {
@@ -257,7 +258,7 @@ if (import.meta.vitest) {
             expect(accounts).toHaveLength(2);
         });
 
-        test("localStorage round-trips and clear empties it", async () => {
+        test("localStorage round-trips and remove deletes a key", async () => {
             const app = createFakeApp();
             await app.localStorage.set("k", "v");
             await app.localStorage.setJSON("o", { n: 1 });
@@ -265,8 +266,10 @@ if (import.meta.vitest) {
             expect(await app.localStorage.getJSON("o")).toEqual({ n: 1 });
             expect(await app.localStorage.get("missing")).toBeNull();
 
-            await app.localStorage.clear();
+            await app.localStorage.remove("k");
             expect(await app.localStorage.get("k")).toBeNull();
+            // Untouched keys stay — there is no clear-all.
+            expect(await app.localStorage.getJSON("o")).toEqual({ n: 1 });
         });
 
         test("cloudStorage round-trips upload -> fetch; computeCid matches upload", async () => {