libid-contracts 0.4.0

Typed alloy bindings, embedded forge artifacts, and deploy/upgrade helpers for the libid contract stack (login, transfer bank diamond, identity names).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

//! Bindings for the Google OIDC verifier
//! (`solidity/contracts/login/oidc/GoogleOidcVerifier.sol`).

/// The surface a deployer and a JWKS rotation listener need. Keep the struct
/// fields in lockstep with the Solidity types.
#[allow(clippy::too_many_arguments, unused_attributes)]
mod inner {
    use alloy::sol;

    sol! {
        #[sol(rpc)]
        interface GoogleOidcVerifier {
            #[derive(Debug, serde::Serialize, serde::Deserialize)]
            struct NotarizedJwksProof {
                bytes notarySignature;
                bytes32 domainHash;
                bytes32 clientRandom;
                bytes32 serverRandom;
                bytes serverEphemeralKey;
                bytes32 transcriptRoot;
                uint256 timestamp;
                bytes32[] domainPath;
                bytes32[] endpointPath;
            }

            #[derive(Debug, serde::Serialize, serde::Deserialize)]
            struct JwkClaim {
                bytes jwkBytes;
                bytes32[] jwkPath;
                bytes kid;
                bytes nB64url;
            }

            /// `_verifier` is the deployed Honk circuit verifier
            /// (`Verifier.sol:HonkVerifier`); `notaryContract_` is the shared
            /// Notary contract; `initialAud` seeds the audience allowlist —
            /// without it the verifier is fail-closed and rejects every proof.
            function initialize(
                address _verifier,
                address _owner,
                address notaryContract_,
                string calldata initialAud
            ) external;

            #[derive(Debug, serde::Serialize, serde::Deserialize)]
            struct RootInfo {
                bytes32 kidHash;
                bytes32 modulusHash;
                uint256 observedAt;
                uint256 expiresAt;
            }

            function setExpectedAudience(string calldata clientId) external;
            function setExpectedAudienceHash(bytes32 audienceHash) external;
            function setRegistry(address r) external;
            function untrustModulus(bytes32 modulusHash) external;

            function modulusOfKid(bytes32 kidHash) external view returns (bytes32);
            function expiresAtKid(bytes32 kidHash) external view returns (uint256);
            function trustedHashExpiresAt(bytes32 modulusHash) external view returns (uint256);
            function platformName() external view returns (string memory);
            function notaryContract() external view returns (address);
            function notary() external view returns (address);
            function currentRoots() external view returns (RootInfo[] memory);
            function freshestObservedAt() external view returns (uint256);
            function needsRotation() external view returns (bool);

            function rotate(NotarizedJwksProof calldata proof, JwkClaim[] calldata claims) external;
            function prune() external;

            event ModulusRotated(bytes32 indexed kidHash, string kid, bytes32 modulusHash, uint256 expiresAt);
            event ModulusUntrusted(bytes32 indexed modulusHash);
            event RootApplied(bytes32 indexed kidHash, bytes32 indexed modulusHash, uint256 observedAt, uint256 expiresAt);
            event RootPruned(bytes32 indexed kidHash, bytes32 modulusHash);
            event AudienceConfigured(bytes32 indexed audienceHash, string clientId);
        }
    }
}

pub use inner::GoogleOidcVerifier;