AnyPS5/docs/dev/debt/libSceNpManager.md

libSceNpManager technical debt

• Older callable NIDs: 7 unidentified exports have unverified names, signatures and behavior. These are throwing import-resolution placeholders; no functionality is implemented. No matching NIDs were found in the later module inventory. Six use the primary logical-library qualifier and one uses ForSys; qualified guest resolution is unverified.

Silent stubs

• sceNpUnregisterPlusEventCallback (libSceNpManager) - returns 0 whether or not a callback was registered, as sceNpUnregisterPremiumEventCallback does: sceNpRegisterPlusEventCallback keeps no callback, and a signed-out user gets no plus events
• sceNpNotifyPremiumFeature (libSceNpManager) - returns 0 without reading its parameter block. Borderlands 4 (PPSA01494), Ghost of Tsushima (PPSA02225), MXGP 26 (PPSA30839) and Super Meat Boy 3D (PPSA31162) call it, and Metal Gear Solid 4 (PPSA18194) imports it
• sceNpSetNpTitleId (libSceNpManager) - returns 0 and keeps neither its title ID nor the 128-byte block passed with it. Forspoken (PPSA03984) and Crimson Desert (PPSA25286) call it once each
• sceNpRegisterPremiumEventCallback, sceNpUnregisterPremiumEventCallback (libSceNpManager) - registration returns SCE_NP_ERROR_INVALID_ARGUMENT for a null callback and otherwise returns 0 without keeping the callback or its user data, so it is never called. Unregistration returns 0. Metal Gear Solid 4 (PPSA18194) imports both

Unknown function info

• libSceNpManager additional exports - 148 callable exports have import-resolution declarations only. Parameter lists, return types and behavior remain unverified. Parameterless int declarations are placeholders, not verified ABI prototypes; every entry throws through NotImplemented_nid_no_patch. Unresolved names use literal NID aliases; no runtime functionality or data objects are fabricated. Existing providers and exports supplied by open pull requests are excluded.

Name	NID
sceNpAsmClientExtAbortRequest	Xi517rrV8MU
sceNpAsmClientExtCreateRequest	yB12TC6fbPo
sceNpAsmClientExtDeleteRequest	yuQrMTiR28k
sceNpAsmClientExtGetPlayingTitleNpTitleToken	zj5wKSAva+Y
sceNpAsmClientExtInitialize	kKCa1japBxI
sceNpAsmClientExtTerminate	yODgcWKSa8Q
sceNpAsmClientGetNpComInfo2WithHmac	fX+iM4sZIl0
sceNpIntUnregisterCheckCallback	IS5vEAFgl0c
sceNpManagerIntBindSandbox	rBQUkjrchjw
sceNpManagerIntClearAdultToChildConversionFlag	vkJy2+W0pJw
sceNpManagerIntClearBcAccessToken	vMbEH4rT5CM
sceNpManagerIntCreateLocalSandboxAdminLoginContext	WM9LDa0us3s
sceNpManagerIntGetAdultToChildConversionFlag	vuKj6MA2ODU
sceNpManagerIntGetBcAccessTokenWithCheck	vuAkL6Dj-JA
sceNpManagerIntGetBcAccessToken	odAzwN-S9G4
sceNpManagerIntGetCachedAccountInfo	mZV+Pm4hvbI
sceNpManagerIntGetClientCredentialJwtAccessToken	PuKANq-Ceqo
sceNpManagerIntGetLocalSandboxAdminSigninState	ADcwKq8Qcxo
sceNpManagerIntGetSandboxList	ZxR0uns1XX8
sceNpManagerIntGetSandboxState	x7Dni-pgA+c
sceNpManagerIntGetStreamingSandboxSecret	9aQPQa73zus
sceNpManagerIntGetVshSandboxClientId	J4pZ9rzjc5s
sceNpManagerIntSetStreamingSandboxSecret	LCgXXwy-Gpg
sceNpManagerIntSignoutLocalSandboxAdmin	qNiQYsQ2fnw
sceNpPush2SetDataType	4CkpTzOLZKQ
sceNpPushSetNpCommunicationId	rjatoAGW+Fo
sceNpPushUnsetNpCommunicationId	j1YsEXl5ta4
sceNpRegisterGamePresenceCallbackA	KswxLxk4c1Y
sceNpSandboxIntAbortRequest	u0apsYwuTvE
sceNpSandboxIntCreateRequest	7IC43AzCrQU
sceNpSandboxIntDeleteRequest	lkgRBuVtWFM
sceNpSandboxIntGetStreamingSandboxSecret	n1tgdduEHu8
sceNpSandboxIntSetStreamingSandboxSecret	OTYUXXdJNbg
Unknown	+JmXFo3Jh6g
Unknown	+RtbJcybMNk
Unknown	+fUJ4QmdNxg
Unknown	+pfQKES7Ghc
Unknown	-1Q057TFjDE
Unknown	-5ZuQ1HlZNY
Unknown	-OrDVMqLIG4
Unknown	-QFXnlDhLNM
Unknown	095ladq7hQ8
Unknown	0cZdUbbTaMw
Unknown	1I4EiKvohEo
Unknown	2o4V3QCvnfg
Unknown	397uJvLrlrM
Unknown	3ikctjJYPtk
Unknown	3sU9cWXBN98
Unknown	4gVqbwFkKGY
Unknown	5FWkeFFM1WI
Unknown	5PZ+-JHIT4c
Unknown	5vBBomYPg+s
Unknown	6Xm6QTvYTTg
Unknown	6ijl2h7IowA
Unknown	7d3y0wXbeGY
Unknown	81ldjv-ybsA
Unknown	899ScRQvFV0
Unknown	AydqLDpvliU
Unknown	BQA2KNZr2H0
Unknown	DDiKTyHJivk
Unknown	DOzHoIo+UK8
Unknown	Dw8yC2rYpT0
Unknown	ETxHcJD5oXQ
Unknown	EtNn1ccn8Ag
Unknown	FN+wQFzswlE
Unknown	FkASC9R1kx4
Unknown	G6+sdb0fbv8
Unknown	GRp4UNp-eCM
Unknown	Gv4cB8leZaU
Unknown	HZg8fgworHI
Unknown	IIlDaVo7WP4
Unknown	IfxfTgE2NAc
Unknown	JYo9EMmaQ7s
Unknown	Jj4yV5S0Eqw
Unknown	JkRtteRXHYw
Unknown	K2pL81xeJA0
Unknown	K3B--gWssAk
Unknown	L1nYyNP96jo
Unknown	LOWrIw66+LQ
Unknown	LpAjW2-Kc14
Unknown	OCHXnB7YbzM
Unknown	P0MZl8cQW78
Unknown	Q49ghYqIP88
Unknown	QZJ5fC0tP8M
Unknown	Qcfj2Iu7f3U
Unknown	TEoGLlZg+r0
Unknown	TICPek76Nqc
Unknown	ThztfmL2j0Y
Unknown	VCYDmZygruk
Unknown	VGkLQcESh5k
Unknown	VisjSq4l+Aw
Unknown	WNGXUCbdhko
Unknown	WmA5X4w-4Sg
Unknown	Wzgnd+m18pQ
Unknown	XbMB+c1klnE
Unknown	XcJr6IO6YVU
Unknown	ZEHVWGnY1vI
Unknown	aQaOGIVChN4
Unknown	aqQDBO03Uw4
Unknown	b1nDsAsD4Fo
Unknown	ckzOf3ihNWs
Unknown	dQ8bBTwkMwg
Unknown	dg8Hm7kd4lg
Unknown	e-J4TWuAGlw
Unknown	enOG3JM+sFE
Unknown	gQygKbb3w6E
Unknown	gg2CzDord9E
Unknown	glO5Roao0-0
Unknown	hABPod2fe5Y
Unknown	hNBwchvmG90
Unknown	hT6stxLyZpg
Unknown	hmUTinCeFlQ
Unknown	i8Iq1bRTvBI
Unknown	i9PldiC93Dg
Unknown	iC9I+uYJfAw
Unknown	j26eOWbUwwo
Unknown	j6YmS-P2zAA
Unknown	jwp0ATrWM+w
Unknown	kpLofCwJceQ
Unknown	krFzyfMTVKo
Unknown	ksopIxjKA6g
Unknown	lB7tiCkrHcw
Unknown	lQfpsyGl4Nc
Unknown	lTaV2Wd+8YA
Unknown	lekBhfAviCg
Unknown	mMqV4jGYBzE
Unknown	nCZMI3Hdzb4
Unknown	p7wseS6VIsU
Unknown	q7oPgJVIywI
Unknown	s7LodS0Puh8
Unknown	sUonpM7eAg8
Unknown	syPuHCOrl-M
Unknown	tCmBna70C6w
Unknown	tHq7rNTBQp0
Unknown	u4zM1slIDrI
Unknown	ue6sId17JRE
Unknown	ukG+D0QVfuQ
Unknown	uqHeyEjZlpA
Unknown	v+6TY5GrDHA
Unknown	vWxlv7-lH78
Unknown	vsJdqui4uB8
Unknown	wN0tvi6mb3o
Unknown	wfhYv1uGwqE
Unknown	wfjSUV5QuDQ
Unknown	wzijRFAxDnk
Unknown	y2cDXtZoz2s
Unknown	z8eiw8+UfEo
Unknown	zLktx8v2g+Y

• sceNpWaitAsync (libSceNpManager) - not measured on a PS5: how the console waits on a request still running is unknown. No request is ever running here, so it never blocks and gives sceNpPollAsync's answers, with that entry's gaps, as shadPS4 does with two identical bodies. The (request id, result) signature follows shadPS4 and SharpProspero

• libSceNpManager pending exports - 144 named callable exports are present in the local libSceNpManager.sprx export table and the public PS5 3.20 symbol list. Their signatures and behavior are unverified; each declaration uses the no-parameter unknown-signature convention and throws through NotImplemented_nid_no_patch.

• sceNpGetSandboxInfo (libSceNpManager, NID ZVZ++68nNI8) - the name hashes to the imported NID (found with nidhunt, confirmed with tools/nid_names.py). PPSA28416 imports it; its OnlineSubsystemPS5 calls it with one pointer to a 0x50-byte stack buffer and reads the buffer as a string (discussions/3086). The returned string, the exact parameter struct and console errors are unknown, so every call throws without reading or writing caller memory. A working implementation belongs with that title's bring-up.

• sceNpUnknown_8weiQyIdI3A: the original name remains unknown. The native wrapper takes a user ID and a read-only 20-byte online-ID record, validates its first byte and sends the record through IPC. The implementation remains a throwing stub.

• sceNpUnknown_WxLcN76q19o: the original name remains unknown. The native wrapper has no input arguments and returns a 32-bit status from an IPC request after initialization checks. The implementation remains a throwing stub.

• sceNpSetTimeout (libSceNpManager) - the signature follows orbital, shadPS4 and SharpProspero; the rejected values (all five 0, negative retries, a resolve timeout under 1 s or another timeout under 10 s, 0 meaning the default) are shadPS4's, not checked on a console. An id that was never created or was deleted returns REQUEST_NOT_FOUND, as in shadPS4; there is no network, so the timeouts are not stored

• sceNpGetUserIdByAccountId - the (account id, user id output) signature and its errors follow shadPS4: account id 0 or a null output returns SCE_NP_ERROR_INVALID_ARGUMENT, and a signed-out NP returns SCE_NP_ERROR_SIGNED_OUT without writing the output. NP is always signed out here, so no account id resolves to a user. PPSA30839 01.003.000 (at 0x447C995 and 0x448C72C) and PPSA34502 01.010.000 (0x712FE2), disassembled for this entry, pass a 64-bit account id and the address of a 32-bit user id on the stack, matching that signature; PPSA30839 sets the user id to -1 before the call, still reads it after a failure, and after a success passes it to its next call

• sceNpNotifyPlusFeature (libSceNpManager) - PS4 titles import it; its parameter block and what the console does with it for a signed-out user are unknown (shadPS4 returns 0 without reading it), so every call throws.

• libSceNpManager pending exports - 189 named callable exports are listed in the PS5 3.20 export table. Their signatures and behavior are unverified; the no-parameter declarations exist for import resolution and throw through NotImplemented_nid_no_patch.

Functional

• sceNpGetAccountCountry, sceNpGetAccountDateOfBirth, sceNpGetAccountLanguage, sceNpGetParentalControlInfo (libSceNpManager) - PS4 forms taking an online id, not measured on a console. Signatures and checks follow shadPS4: a null pointer is INVALID_ARGUMENT; no user is signed in, so no online id matches one and the rest return USER_NOT_FOUND without writing, like sceNpCheckNpAvailability. Request ids are not checked

• sceNpCheckNpAvailabilityA, sceNpGetAccountDateOfBirthA, sceNpGetAccountLanguageA, sceNpGetGamePresenceStatus, sceNpGetGamePresenceStatusA, sceNpGetParentalControlInfoA (libSceNpManager) - answer as if no PSN account is signed in; the signed-in behaviour is not implemented and none of it is measured on a console. Checks follow shadPS4: a null pointer or user id -1 is INVALID_ARGUMENT, then request id 0 is INVALID_ARGUMENT and an unknown one REQUEST_NOT_FOUND. Other users get SIGNED_OUT with nothing written, as from sceNpGetAccountCountryA; shadPS4's sceNpGetAccountDateOfBirthA returns USER_NOT_FOUND for a user it does not know. An async request gets SIGNED_OUT from the call; shadPS4 returns 0 and leaves it to sceNpPollAsync. The presence queries write OFFLINE (0) and return 0

• sceNpHasSignedUp, sceNpCheckNpReachability (libSceNpManager) - answer as if no PSN account is signed in: sceNpHasSignedUp reports false for every user and sceNpCheckNpReachability returns SCE_NP_ERROR_SIGNED_OUT without reading its request or user ID. Tests pin both answers; no console run measured them. shadPS4 (PS4, src/core/libraries/np/np_manager.cpp, commit 0614ce324be092791b758d79f93d9f1ca5b10a81) reports true for sceNpHasSignedUp only when a shadNet NPID is configured for the user and USER_NOT_FOUND for an unknown one, and sceNpCheckNpReachability looks up the request first; KytyPS5 (PS5, src/libs/network.cpp, commit 5e837a9beac82c031868eaad9348d6a48245fb99) reports false and also looks up the request; fpPS4 (PS4, src/np/ps4_libscenpmanager.pas, commit 04cefd43e6fddd1ab033e7980cd356d14c964905) reports true and returns 0.

• sceNpGetUserIdByOnlineId (libSceNpManager) - the (online id, user id output) signature follows shadPS4: a null online id or output returns SCE_NP_ERROR_INVALID_ARGUMENT, and a signed-out NP returns SCE_NP_ERROR_SIGNED_OUT without writing the output, as sceNpGetUserIdByAccountId does

• sceNpCheckPlus (libSceNpManager) - the (request id, parameter, result) signature follows shadPS4: request id 0 or a null parameter or result returns SCE_NP_ERROR_INVALID_ARGUMENT, and every other call returns SCE_NP_ERROR_SIGNED_OUT without writing the result, as sceNpCheckPremium does. The parameter's size and feature fields, which shadPS4 checks, are not read: the errors the console returns for them are not known

• sceNpGetAccountId, sceNpSetGamePresenceOnline (libSceNpManager) - PS4 forms; the (online id, account id output) and (request id, online id, presence) signatures follow shadPS4. A null online id or output, or request id 0 for sceNpSetGamePresenceOnline, returns SCE_NP_ERROR_INVALID_ARGUMENT. sceNpSetGamePresenceOnline then returns SCE_NP_ERROR_REQUEST_NOT_FOUND for a request that was never created or was deleted, as shadPS4 does. Otherwise both return SCE_NP_ERROR_SIGNED_OUT without writing, as sceNpGetAccountIdA does. The console's result for a signed-out user is not measured

• NP reachability callbacks retain one callback and its user data; duplicate registration and unregistering an absent callback return the errors used by shadPS4. No callback is delivered because the existing NP model remains signed out with reachability unavailable.

• sceNpCheckNpAvailability: native NP initialization and online-ID lookup are not modeled. The offline host returns user-not-found for valid arguments after clearing the optional one-byte availability output; request ID 0 and a null online-ID pointer return invalid-argument before writing the output.

• NP state callbacks (libSceNpManager) - the registration rules are shadPS4's: sceNpRegisterStateCallbackA keeps up to 8 callbacks and returns the slot plus 1, a null callback returns INVALID_ARGUMENT, a callback already registered CALLBACK_ALREADY_REGISTERED and a ninth one CALLBACK_MAX (0x8055001D, np_error.h); the unregister errors are in the next entry; the legacy sceNpRegisterStateCallback keeps one callback with the same errors. Each registration gets SIGNED_OUT for the initial user (0x10000000) once, from the next sceNpCheckCallback on the calling thread. For the A form this follows KytyPS5, whose sceNpRegisterStateCallbackA marks the registration pending. KytyPS5 never calls the legacy callback (sceNpRegisterStateCallback stores nothing); it is called as (user, SIGNED_OUT, nullptr, userdata), as in shadPS4, which passes an NpId only for SIGNED_IN (L823, L938-L940). shadPS4 instead queues SIGNED_OUT from the user service login event and delivers it from sceNpCheckCallback (DispatchPendingNpStateCallbacks); the reachability callback is not given an initial UNAVAILABLE, unlike that function (L922-L961). A callback being delivered when another thread unregisters it is still called once. When and how often the console calls the state callbacks, and the errors, are not measured

• sceNpRegisterStateCallbackA and sceNpUnregisterStateCallbackA (libSceNpManager) - never return the module's 0x80550002 for a failed readiness check, whose input is not known, and are not measured on a PS5. An unregister id outside 1..8, compared unsigned so 0 and negative ids are included, returns INVALID_ID (0x80550015) and an empty slot CALLBACK_NOT_REGISTERED, as prosper reads libSceNpManager.sprx at RVA 0x15b10, without recording its firmware version; the same reading gives the registration rules above (L162-L175)

• sceNpRegisterGamePresenceCallback (libSceNpManager) - accepts any callback, null included, and returns nothing; no game presence event is delivered because the NP model remains signed out. Kyty ignores the callback the same way, and shadPS4 keeps the last one without calling it. Not measured on a PS5

• sceNpIsPlusMember and sceNpSetContentRestriction (libSceNpManager) - the signatures and checks follow shadPS4: a null output or restriction is INVALID_ARGUMENT, a restriction size other than 0x18 is INVALID_SIZE (0x80550011), and a negative default age, more than 256 age restrictions or a count without an array is INVALID_ARGUMENT. Any user is reported as not a Plus member, and a valid restriction is accepted and not stored. Not measured on a PS5

• sceNpCheckCallbackForLib (libSceNpManager) - not measured on a PS5: it delivers the pending state callbacks like sceNpCheckCallback, as shadPS4 does with its pending state events; shadPS4's sceNpCheckCallback also runs other registered NP callbacks, which this library does not keep

• sceNpAbortRequest (libSceNpManager) - a request id that was never created or was deleted returns SCE_NP_ERROR_REQUEST_NOT_FOUND and a live request returns 0, as shadPS4 does in sceNpAbortRequest; shadPS4 there also moves the request into an Aborted state that its later requests read as ABORTED, and whether aborting on the console changes a live request's completion is not measured on a PS5 (#9277), so nothing in this library reads an abort state and the id stays live

• sceNpDeleteRequest (libSceNpManager) - a request id that was never created or was deleted returns SCE_NP_ERROR_REQUEST_NOT_FOUND, and a live request is removed and returns 0, as shadPS4 does in sceNpDeleteRequest (#9277)

• sceNpIdMapperCreateRequest, sceNpIdMapperDeleteRequest, sceNpIdMapperAbortRequest (libSceNpManager) - the in-library check is measured on firmware 13.42 libSceNpManager.sprx by BunnyFl: delete and abort refuse a request id of 0 or less with 0x80553085, and the rest goes to the NP service (create through np::ipc::service_client::CreateRequest, abort through sceNpAsmClientAbortRequest, delete through sceNpAsmClientAbortRequest and sceNpAsmClientDeleteRequest). The service's answers follow main's offline model of sceNpCreateRequest, not a console measurement: a counter of their own hands out ids from 1, abort leaves a live request live, delete frees it, and an id never created or already deleted returns SCE_NP_ERROR_REQUEST_NOT_FOUND

• sceNpManagerIntCreateRequest, sceNpManagerIntDeleteRequest, sceNpManagerIntAbortRequest (libSceNpManager) - the in-library table is measured on firmware 13.42 libSceNpManager.sprx by BunnyFl: 64 slots, so the 65th live request gives 0x80559D05 without asking the service; create returns a negative or zero service id as is and refuses one already live with 0x80559D03; delete gives 0x80559D0A for an id not in the table and frees a live one; abort has no local lookup. The ids and the abort answer follow main's offline model, not a console measurement: a counter of this family's own hands out ids from 1, and abort answers SCE_NP_ERROR_REQUEST_NOT_FOUND for an id the service does not hold. The measured in-use path (a request held by a running call is only marked deleted) is not reached, since no call holds a request

• sceNpIdMapperNpIdToAccountId, sceNpIdMapperOnlineIdToAccountId (libSceNpManager) - the argument checks are measured on firmware 13.42 libSceNpManager.sprx by BunnyFl: seven arguments (request id, user id, an input pointer, an output pointer, a 32-bit value, a byte and a seventh argument); a request id of 0 or less gives 0x80553085, then user id -1, a null pointer or the value outside 1 to 1000 gives 0x80553083, and the byte and the seventh argument are not checked. Past them the request goes to the NP service, whose answer follows main's offline model of the public twins, not a console measurement: SCE_NP_ERROR_SIGNED_OUT, writing nothing. The SDK names of the two codes are not known, so their constants are named after the checks

• NP service client initialization (libSceNpManager) - not modelled, so 0x80550002 is never returned: BunnyFl measured it before the library's NP service client exists from sceNpManagerIntCreateRequest, sceNpManagerIntDeleteRequest and sceNpManagerIntAbortRequest (measured on firmware 13.42 libSceNpManager.sprx by BunnyFl) and, before any argument check, from the eleven NpManagerInt getters (the #10890 measurement), and main keeps no initialized state for this library

• sceNpIdMapperAccountIdToNpId, sceNpIdMapperAccountIdToOnlineId (libSceNpManager) - still throw: this library gives no answer for an account id mapped to an online id or NpId (sceNpManagerIntGetOnlineIdByAccountId has no export here), and what a signed-out user's account id is depends on the offline account-id model of #6990 and #7412

• sceNpManagerIntGetAccountAge, sceNpManagerIntGetAccountCountryA, sceNpManagerIntGetAccountLanguageA, sceNpManagerIntGetNpId, sceNpManagerIntGetOnlineId (libSceNpManager) - the argument checks are measured on firmware 13.42 libSceNpManager.sprx by BunnyFl: user id -1 or a null output gives SCE_NP_ERROR_INVALID_ARGUMENT, and GetAccountAge and GetAccountLanguageA look their request id up only after the checks. Past them the call goes to the NP service, whose answer follows main's offline model of the public twins, not a console measurement: SCE_NP_ERROR_SIGNED_OUT, writing nothing, for any request id, since the request lookup's own answer is not measured

• sceNpManagerIntGetUserIdByOnlineId, sceNpManagerIntGetUserIdByNpId (libSceNpManager) - the argument checks are measured on firmware 13.42 libSceNpManager.sprx by BunnyFl: a null input or output gives SCE_NP_ERROR_INVALID_ARGUMENT. Past them the answer follows main's offline model of sceNpGetUserIdByOnlineId, not a console measurement: SCE_NP_ERROR_SIGNED_OUT, writing nothing

• sceNpManagerIntAuthGetAuthorizationCode, sceNpManagerIntAuthGetIdToken, sceNpManagerIntGetAuthorizationCode, sceNpManagerIntGetAuthorizationCodeWithPsnoUri (libSceNpManager) - the arities and checks are measured on firmware 13.42 libSceNpManager.sprx by BunnyFl, with no libSceNpAuth layout: user id -1 or a required pointer null gives SCE_NP_ERROR_INVALID_ARGUMENT, as do the eight-argument call's values outside 0 to 3 and 1 to 3; a mode other than 0, 3 or 5 gives 0x80550004; the URI form refuses a size outside 1 to 0x801 with 0x80550011, then the mode, then a URI of 0x2000 bytes or more with 0x80550005 (terminator unmeasured). Past the checks the answer follows main's offline model, not a console measurement: SCE_NP_ERROR_SIGNED_OUT, writing nothing, for any request id; the request lookup and the URI form's sceHttpUriParse step are not modelled

• sceNpManagerIntGetAccountId, sceNpManagerIntGetAccountIdSdk, sceNpManagerIntGetUserIdByAccountId (libSceNpManager) - still throw: their answer or their input is an account id, and what a signed-out user's account id is depends on the offline account-id model of #6990 and #7412, as for sceNpIdMapperAccountIdToNpId

• sceNpPollAsync (libSceNpManager) - a null result pointer returns SCE_NP_ERROR_INVALID_ARGUMENT before the id is read, a request id that was never created or was deleted returns SCE_NP_ERROR_REQUEST_NOT_FOUND without writing the caller's result, and a live request keeps its signed-out completion 0 with SCE_NP_ERROR_SIGNED_OUT, as shadPS4 does in sceNpPollAsync (#9277). The parts of that model beyond the validation are not implemented: shadPS4 keeps a per-request state machine decorated by sceNpCheckNpAvailability and neighbors and refuses InvalidId for a ready async request in wait/poll, whose completion publication, poll-versus-wait precedence and already-complete errors remain unattributable to the PS5

• sceNpCreateAsyncRequest (libSceNpManager) - the parameter is not read (NpCreateAsyncRequestParameter is a 0x40-byte opaque blob, so shadPS4's nonnull check and size == sizeof reject (81be949167d0060b08f26dc3e055a0b640d129c8) cannot be applied without inventing a layout) and no async kind or completion state is stored until the console's contract for them is evidenced (#9277)

Additional-export identity evidence

This additional inventory is the inspected libSceNpManager ELF function-export table: defined STT_FUNC entries with 11-character NIDs. The module-parameter record contains version words 0x13590001 at 0x10 and 0x13600007 at 0x14; the earlier 13.60 wording referred to that SDK-formatted metadata and does not independently attest retail firmware or introduction dates.

The reproducible static audit yields 539 unique function NIDs, set digest cbae5a1be711881f881e750ded1e817aba9e4f0cde69fdaee47f29585ceb3ecd (sorted unique ASCII NIDs, each followed by LF, hashed with SHA-256), and confirms all 148 proposed entries. The independent 13.42 comparison also reports all 148 entries in a 539-NID module. That corroborates membership in the reviewer's reference; it does not identify the two images as the same binary or authenticate firmware provenance. The older 3.20 inventory is not the evidence for this additional set. The symbol table supplies hashes and callable kind, not C prototypes or plaintext spellings.

All 33 named declarations were matched by recomputing candidate spellings against the function NIDs; none is assigned by ordinal or neighbouring address. The repository-pinned aerolib table contains 22 of the pairs. The other 11 candidates occur in the public ps5rs identity database at commit 2304be5131221bae0dac24b9767cabffda33f747; each independently hashes to a function NID in the inspected table. That public database supports spelling only, not firmware attribution or ABI. The remaining 115 exports stay NID-only.

Supplemental candidate spelling	NID
sceNpManagerIntClearBcAccessToken	vMbEH4rT5CM
sceNpManagerIntSetStreamingSandboxSecret	LCgXXwy-Gpg
sceNpManagerIntGetClientCredentialJwtAccessToken	PuKANq-Ceqo
sceNpManagerIntGetStreamingSandboxSecret	9aQPQa73zus
sceNpSandboxIntSetStreamingSandboxSecret	OTYUXXdJNbg
sceNpSandboxIntCreateRequest	7IC43AzCrQU
sceNpSandboxIntDeleteRequest	lkgRBuVtWFM
sceNpSandboxIntAbortRequest	u0apsYwuTvE
sceNpSandboxIntGetStreamingSandboxSecret	n1tgdduEHu8
sceNpAsmClientExtTerminate	yODgcWKSa8Q
sceNpPush2SetDataType	4CkpTzOLZKQ