@pvium/p2id-core 0.1.2 → 0.2.0

package/contracts/interfaces/IP2IDVerifier.sol

@@ -2,9 +2,11 @@
 pragma solidity ^0.8.27;
 
 /// @title IP2IDVerifier
-/// @notice Use-case-agnostic identity verification: given a proof, return the wallet the proven
-///         identity resolves to. Optionally also verify a funding constraint.
+/// @notice Resolve an identity proof to a wallet and issue time, with optional constraint evidence.
 interface IP2IDVerifier {
+    /// @notice Trusted key-artifact SHA-256 pinned by this verifier; never read from caller metadata.
+    function vkHash() external view returns (bytes32);
+
     /// @notice A funding constraint and the evidence that it is satisfied.
     /// @param commitment bytes32(0) = no constraint; otherwise the commitment a deposit was funded with.
     /// @param signature  Evidence for `commitment`; for PviumVerifier, the registered signer's
@@ -15,9 +17,7 @@ interface IP2IDVerifier {
         bytes signature;
     }
 
-    /// @param identityHash The identity the caller expects the proof to be for (e.g. the vault's
-    ///                     commitment). Proofs are public once used on-chain, so the caller MUST
-    ///                     pin the identity rather than trust whatever the submitted proof proves.
+    /// @param identityHash Expected identity commitment that the implementation must match against the proof.
     /// @param proof        Opaque identity proof; the implementation defines the encoding.
     /// @param constraint   Skipped when `constraint.commitment == bytes32(0)`.
     /// @return wallet Wallet associated with the proven identity (never address(0)).
@@ -30,15 +30,14 @@ interface IP2IDVerifier {
         Constraint calldata constraint
     ) external view returns (address wallet, uint64 iat);
 
-    /// @notice Whether this verifier can ever satisfy a non-zero constraint. Vaults refuse
-    ///         constrained deposits under a verifier that returns false (or does not implement
-    ///         this), so a payer cannot lock funds behind a condition nobody can meet.
+    /// @notice Whether this verifier currently supports nonzero constraints. P2IDVault requires
+    ///         a successful true response when funding a constrained deposit; this does not establish
+    ///         that any particular commitment can be satisfied.
     function supportsConstraints() external view returns (bool);
 
-    /// @notice Changes (increments) whenever proofs this verifier accepted before may no longer be
-    ///         trusted, e.g. a signing key was revoked. A vault caches the wallet a proof resolved
-    ///         to and pays it without re-verifying; it discards that cache when the revision moved,
-    ///         so revoking a key also revokes what was proven under it. Return a constant if
-    ///         nothing this verifier trusts can ever be revoked.
+    /// @notice Cache revision. Implementations must increment it when previously accepted identity
+    ///         proofs may no longer be trusted, or return a constant if trust cannot be revoked.
+    /// @dev P2IDVault rejects cached-owner claims when this differs from the stored revision, and
+    ///      rejects cached-owner claims and proof updates when the revision cannot be read.
     function revision() external view returns (uint64);
 }

package/contracts/interfaces/IP2IdVaultFactory.sol

@@ -2,30 +2,64 @@
 pragma solidity ^0.8.27;
 
 /// @title IP2IdVaultFactory
-/// @notice Deploys one P2IDVault per identity at an address anyone can derive offline from the
-///         identity hash, and points every vault at the current policy and default verifier.
+/// @notice Vault proxy deployment, address derivation, funding and shared configuration views.
 interface IP2IdVaultFactory {
     event VaultDeployed(bytes32 indexed identityHash, address indexed vault);
+    event ImplementationProposed(address indexed implementation, uint64 eta);
+    event ImplementationProposalCancelled(address indexed implementation);
+    event ImplementationRegistered(address indexed implementation);
+    event ImplementationDeployed(address indexed implementation, bytes32 creationCodeHash);
+    event ImplementationDefaultProposed(address indexed implementation, bool makeDefault, uint64 eta);
+    event DefaultImplementationActivated(address indexed implementation);
+    event ImplementationRevoked(address indexed implementation);
 
     /// @notice P2ID factory interface version implemented by this contract.
     function p2idVersion() external pure returns (string memory);
 
-    // ---- what vaults consult on every call; both change only through a timelock ----
-    /// @notice The IP2IDPolicy deciding which verifiers are allowed and what (capped) fee applies.
+    // ---- shared configuration ----
+    /// @notice Policy address used for verifier approval, fee quotes and fee distribution.
     function policy() external view returns (address);
     /// @notice Verifier used when a payer does not choose one, and the one bare transfers are claimed through.
     function defaultVerifier() external view returns (address);
+    /// @notice Whether proofs under `vkHash` need an alpha attestation: true for every key until released.
+    function isAlpha(bytes32 vkHash) external view returns (bool);
+    function setDefaultAttester(address attester) external;
+    function defaultAttester() external view returns (address);
+    function alphaRevision(bytes32 vkHash) external view returns (uint256);
+    function alphaEpoch() external view returns (uint256);
+    function verifyAlphaAuthorization(address vault, address caller, bytes32 callHash, uint256 nonce, uint256 deadline, bytes calldata signature) external view;
+
+    // ---- vault implementations ----
+    /// @notice The implementation every newly deployed vault proxy starts on.
+    function baseImplementation() external view returns (address);
+    /// @notice Whether the implementation is registered as an upgrade target; other upgrade checks also apply.
+    function isRegisteredImplementation(address implementation) external view returns (bool);
+
+    function initialImplementation() external view returns (address);
+    function implementationFor(bytes32 creationCodeHash) external view returns (address);
+    /// @notice Deploy full creation code and propose registration; makeDefault applies after the delay.
+    function deployVaultImplementation(bytes memory creationCode, bool makeDefault) external returns (address);
+    function proposeDefaultImplementation(address implementation) external;
+
+    // ---- address derivation constants ----
+    /// @notice Namespace value supplied to the factory constructor and passed to vault initialization.
+    function nsHash() external view returns (bytes32);
+    /// @notice Proxy creation-code hash used with this factory's address and an identityHash for CREATE2 derivation.
+    function initCodeHash() external pure returns (bytes32);
+    /// @notice Refund-window bounds passed to new vaults during initialization.
+    function minRefundWindow() external view returns (uint64);
+    function maxRefundWindow() external view returns (uint64);
 
     // ---- vaults ----
     /// @notice The vault address for `identityHash`, deployed or not:
-    ///         `keccak256(0xff ‖ factory ‖ identityHash ‖ keccak256(P2IDVault creationCode))`.
+    ///         Low 160 bits of `keccak256(0xff || factory || identityHash || initCodeHash())`.
     function vaultFor(bytes32 identityHash) external view returns (address);
     function isDeployed(bytes32 identityHash) external view returns (bool);
     /// @notice Deploy the vault for `identityHash`; returns the existing one if already deployed.
     function deploy(bytes32 identityHash) external returns (address vault);
     /// @notice Deploy if needed, then fund under the default verifier on the caller's behalf
-    ///         (caller keeps the refund right). ERC-20: approve this factory once to pay any
-    ///         identity. Native coin: token = address(0), send `amount` as msg.value.
+    ///         (caller is recorded as funder). ERC-20: approve this factory for the requested amount.
+    ///         Native coin: token = address(0), send `amount` as msg.value.
     /// @param ref Opaque application reference forwarded to the vault's Funded event; bytes32(0) for none.
     function fund(
         bytes32 identityHash,

package/contracts/interfaces/IPviumIdentity.sol

@@ -2,19 +2,18 @@
 pragma solidity ^0.8.27;
 
 /// @title IPviumIdentity
-/// @notice Verify a Pvium attestation on chain: "identity X and wallet W belong to the same
-///         Privy user". Every function reverts unless the proof is valid, was made from a token
-///         signed by one of the accepted keys, and binds exactly the values given. The return value is
-///         when Privy issued that token (unix seconds); freshness policy is the caller's.
+/// @notice Attestation verification and signer/version views exposed by PviumIdentity.
+///         verifyIdentity checks the supplied identity type, identity hash and wallet hash.
 interface IPviumIdentity {
     /// @notice Circuit version this deployment verifies. Attestations state theirs; use the matching deployment.
+    function vkHash() external view returns (bytes32);
     function circuitVersion() external view returns (uint16);
-    /// @notice Whether tokens signed by this P-256 key are accepted. Keys are added with 7 days' public notice.
+    /// @notice Whether this P-256 key belongs to the deployment's current accepted signer set.
     function isSignerKey(uint256 x, uint256 y) external view returns (bool);
 
     /// @notice Verify that the proof binds exactly this identity and this wallet.
-    /// @dev Both are passed as hashes (P2IDHash on chain, or the SDK's identityHash), so the raw
-    ///      identity never appears in calldata.
+    /// @dev The expected identity and wallet are supplied as hashes. The function does not impose
+    ///      an age limit on the attestation.
     /// @param identityType Identity type id: 0 email, 3 twitter, 5 github, … (see P2IDHash)
     /// @param identityHash P2IDHash.identityHash(identityType, value)
     /// @param walletHash   P2IDHash.walletHash(wallet): an address, or a string for a non-EVM wallet

package/contracts/lib/P2IDHash.sol

@@ -2,10 +2,10 @@
 pragma solidity ^0.8.27;
 
 /// @title P2IDHash
-/// @notice The identity commitment exactly as circuit/src/main.nr computes it:
+/// @notice Identity commitment:
 ///         sha256("p2id.identity.v1" || identityType || normalize(value)).
-///         `normalize` ASCII-lowercases every type except phone and wallet, and lowercases
-///         `0x…` (EVM, hex) wallet addresses; base58 (Solana) addresses are untouched.
+///         Normalization ASCII-lowercases non-phone, non-wallet values. Wallet values are
+///         lowercased only when they start with lowercase `0x`; other wallet strings are unchanged.
 library P2IDHash {
     bytes internal constant PREFIX = "p2id.identity.v1";
     uint8 internal constant PHONE = 1;
@@ -27,7 +27,7 @@ library P2IDHash {
         return sha256(abi.encodePacked(PREFIX, WALLET, toLowerHex(wallet)));
     }
 
-    /// @notice Commitment for a wallet on any chain, given as Privy stores it (e.g. base58).
+    /// @notice Wallet-string commitment using type 12, with identityHash's normalization and length checks.
     function walletHash(string memory wallet) internal pure returns (bytes32) {
         return identityHash(WALLET, bytes(wallet));
     }
@@ -48,7 +48,7 @@ library P2IDHash {
         return out;
     }
 
-    /// @dev "0x" + 40 lowercase hex chars, the form the circuit hashes an EVM address in.
+    /// @dev Encode an address as "0x" followed by 40 lowercase hexadecimal characters.
     function toLowerHex(address a) internal pure returns (bytes memory out) {
         bytes16 digits = "0123456789abcdef";
         out = new bytes(42);

package/dist/cjs/p2idConstants.js

@@ -5,10 +5,10 @@ exports.P2ID_SCHEME = exports.P2ID_SCHEMES = void 0;
 exports.P2ID_SCHEMES = {
     "pvium.vault.v1": {
         "identityDomain": "p2id.identity.v1",
-        "vaultInitCodeHash": "0x59c2f7f1e9725340e25a45b122fae7d1e9cbd9c7b00dba6215ebaa67cfb691ef",
+        "vaultInitCodeHash": "0x23dec57677be79edb9ad208117422435778ee00c12d4c56e2edf226d2a57b18a",
         "factories": {
             "production": null,
-            "sandbox": "0xd1DEa4e8911955DAD961B643AFdE6Ab34d9Bd371"
+            "sandbox": "0x48fD1bc4f982342dCFe2BEAc5fCFd22b4c1Ba4f6"
         }
     }
 };

package/dist/esm/p2idConstants.d.ts

@@ -18,10 +18,10 @@ export interface P2IDScheme {
 export declare const P2ID_SCHEMES: {
     readonly "pvium.vault.v1": {
         readonly identityDomain: "p2id.identity.v1";
-        readonly vaultInitCodeHash: "0x59c2f7f1e9725340e25a45b122fae7d1e9cbd9c7b00dba6215ebaa67cfb691ef";
+        readonly vaultInitCodeHash: "0x23dec57677be79edb9ad208117422435778ee00c12d4c56e2edf226d2a57b18a";
         readonly factories: {
             readonly production: null;
-            readonly sandbox: "0xd1DEa4e8911955DAD961B643AFdE6Ab34d9Bd371";
+            readonly sandbox: "0x48fD1bc4f982342dCFe2BEAc5fCFd22b4c1Ba4f6";
         };
     };
 };

package/dist/esm/p2idConstants.js

@@ -2,10 +2,10 @@
 export const P2ID_SCHEMES = {
     "pvium.vault.v1": {
         "identityDomain": "p2id.identity.v1",
-        "vaultInitCodeHash": "0x59c2f7f1e9725340e25a45b122fae7d1e9cbd9c7b00dba6215ebaa67cfb691ef",
+        "vaultInitCodeHash": "0x23dec57677be79edb9ad208117422435778ee00c12d4c56e2edf226d2a57b18a",
         "factories": {
             "production": null,
-            "sandbox": "0xd1DEa4e8911955DAD961B643AFdE6Ab34d9Bd371"
+            "sandbox": "0x48fD1bc4f982342dCFe2BEAc5fCFd22b4c1Ba4f6"
         }
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pvium/p2id-core",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "P2ID protocol core: identity types and hashing, chain-agnostic P2ID address derivation, and the Solidity sources",
   "license": "MIT",
   "type": "module",