# V4 ADR source evidence: the cert-surface scan, V4's link refusal and the GPS operations, at pinned revisions (7 October 2026)

Evidence for the V4 ADR (Eve 26e27ea1), supplied for review cfc88322. Everything in the code blocks is copied from the repository by `git show <revision>:<path>`; lines longer than 220 characters are cut at 220.

- **V4 source revision:** `d092109ae624d9cb573a1dd2b8358bf08b8db75e`, the last commit to change `apps/v4`. Its tree there and at main `307bbbdfbb6` is the same object (`34351c794cb1`). There is no `libs/v4`.
- **GPS contract revision:** `1e5a2680f7a6ffa79b747aa1c3d39ab19034af17`, the last commit to change `libs/contracts/src/gps/`.

## 1. The cert-surface scan

The registry `V2/legal/platform-cert-bans.json` at the V4 source revision maps its surfaces to packages:

| surface | packages |
| --- | --- |
| `web3_cosmetic_ownership` | `@aje/identity`, `@aje/nft` |
| `cosmetic_nft_ownership` | `@aje/nft` |
| `on_chain_in_game_items` | `@aje/identity`, `@aje/nft` |
| `fan_token_gated_gameplay` | `@aje/governance` |
| `on_chain_rights_manifest` | `@aje/rwa` |

Command: `git grep -n -E '@aje/(identity|nft|governance|rwa)' d092109ae624 -- apps/v4 V4/store`

Exit status 1, 0 matching lines: no file under `apps/v4` or `V4/store` at the revision names any of the four packages. `apps/v4` is Rust crates; the same search for the crate-style names finds nothing either:

Command: `git grep -n -i -E 'aje[-_](identity|nft|governance|rwa)' d092109ae624 -- apps/v4 V4/store`: exit status 1, 0 matching lines.

There is no `V4/legal/platform-cert-bans.json`.

## 2. The GPS contract's publish step

`libs/contracts/src/gps/entitlements.ts` lines 228–288 at `1e5a2680f7a6`. `gpsPublishGrant` takes the registry on every call; the file has no publish path without it.

```ts
/**
 * Check a declaration against the cert-ban registry on the publish date, and
 * publish it only when no target platform and region bans, or fails to clear,
 * a surface it exposes.
 */
export function gpsPublishGrant(
  declaration: GpsGrantDeclaration,
  item: GpsCatalogItem,
  registry: GpsCertBanRegistry,
  publishedAt: string
): GpsGrantPublication {
  const parsed = GpsGrantDeclarationSchema.parse(declaration);
  const catalogItem = GpsCatalogItemSchema.parse(item);
  if (catalogItem.itemRef !== parsed.itemRef || catalogItem.product !== parsed.consumingProduct) {
    throw new Error(
      `The catalog item ${catalogItem.product}/${catalogItem.itemRef} is not the grant's ${parsed.consumingProduct}/${parsed.itemRef}.`
    );
  }
  const derived = gpsSurfacesOf(catalogItem, registry);
  const declared = new Set(parsed.platformConstraints.certSurfaces);
  const undeclaredSurfaces = derived.filter((surface) => !declared.has(surface));
  // Check everything the item exposes, and anything more the publisher declared.
  const surfaces = [...new Set([...derived, ...declared])];
  const date = publishedAt.slice(0, 10);
  const violations: GpsCertViolation[] = [];
  if (surfaces.length > 0) {
    const inEffect = registry.entries.filter((entry) => entryInEffect(entry, date));
    for (const platform of parsed.platformConstraints.platforms) {
      // `*` means every region: only a wildcard entry speaks for all of them.
      const regions = parsed.platformConstraints.regions.includes('*')
        ? ['*']
        : parsed.platformConstraints.regions;
      for (const region of regions) {
        const entries = inEffect.filter((entry) => entryCovers(entry, platform, region));
        if (entries.length === 0) {
          violations.push({ platform, region, surface: null, reason: 'no-entry-in-effect' });
          continue;
        }
        for (const surface of surfaces) {
          if (entries.some((entry) => entry.bannedSurfaces.includes(surface))) {
            violations.push({ platform, region, surface, reason: 'banned' });
          } else if (!entries.some((entry) => entry.explicitlyClearedSurfaces.includes(surface))) {
            violations.push({ platform, region, surface, reason: 'not-cleared' });
          }
        }
      }
    }
  }
  if (violations.length > 0 || undeclaredSurfaces.length > 0) {
    return { published: false, violations, undeclaredSurfaces };
  }
  return {
    published: true,
    grant: {
      declaration: parsed,
      publishedAt,
      registryReviewed: registry.lastReviewed,
      itemManifestSha256: catalogItem.manifest.sha256,
    } as GpsPublishedGrant,
  };
}
```

## 3. V4's link refusal today

`apps/v4/online-services/src/lib.rs` lines 469–510 at `d092109ae624` (blob `13074502ef25`): a platform account already linked to another account is refused.

```rust
    pub fn link_platform_account(
        &mut self,
        account_id: &str,
        provider_id: &str,
        platform_user_id: &str,
    ) -> bool {
        if account_id.is_empty() || provider_id.is_empty() || platform_user_id.is_empty() {
            return false;
        }
        if self
            .first_party_accounts
            .iter()
            .any(|(existing_id, account)| {
                existing_id != account_id
                    && account.links.iter().any(|link| {
                        link.provider_id == provider_id && link.platform_user_id == platform_user_id
                    })
            })
        {
            return false;
        }

        let Some(account) = self.first_party_accounts.get_mut(account_id) else {
            return false;
        };
        if let Some(link) = account
            .links
            .iter_mut()
            .find(|link| link.provider_id == provider_id)
        {
            link.platform_user_id = platform_user_id.to_owned();
            link.entitlements_imported = true;
        } else {
            account.links.push(LinkedPlatformAccount {
                provider_id: provider_id.to_owned(),
                platform_user_id: platform_user_id.to_owned(),
                primary: false,
                entitlements_imported: true,
            });
        }
        true
    }
```

## 4. The GPS link operation's refusals

`libs/contracts/src/gps/openapi.ts` lines 336–350 at `1e5a2680f7a6`: the operation lists 403 and 422 and no refusal for a platform account linked elsewhere.

```ts
      post: write({
        tag: 'session',
        operationId: 'createGpsPlatformLink',
        description:
          "Link a store account to the V1 subject's Oshun account, through this game. GPS verifies the store's proof with the store before it records the link and sets its verification time; the link belongs to the accou
        credential: 'v1Bearer',
        parameters: [GAME_ID, ACCOUNT_ID],
        request: 'GpsPlatformLinkRequest',
        example: GPS_PLATFORM_LINK_REQUEST_FIXTURE,
        response: 'GpsPlatformLink',
        refusals: {
          '403': NOT_THE_SUBJECT,
          '422': 'The store did not accept the proof for that platform account.',
        },
      }),
```

## 5. The telemetry refusal reasons

`libs/contracts/src/gps/telemetry.ts` at `1e5a2680f7a6`, the lines that name the six refusal reasons the ADR's rollout handles:

```ts
95: | 'unregistered-event-type'
96: | 'unregistered-version'
97: | 'missing-field'
98: | 'undeclared-field'
99: | 'wrong-type'
100: | 'account-not-declared';
112: 'unregistered-event-type',
113: 'unregistered-version',
```

## What this does not show

- The scan shows that no V4 file names the registry's packages. The contract derives surfaces from the catalog item's manifest at publish time, not from this scan.
- It does not run V4's services or GPS; there is no GPS implementation to run yet, only its contracts.
