···

       
25
       
 
       
    const channelsValue = useContext(ChannelsContext);

     

       
26
       
 
       
    if (!channelsValue)

     

       
27
       
 
       
        throw new Error(

     

       
28
       
-
       
            "Channels context was null. Did you try to access this outside of the authed providers? ChannelsProvider must be below OAuth provider.",

     

       
29
       
 
       
        );

     

       
30
       
 
       
    return channelsValue;

     

       
31
       
 
       
};

     

···

       
25
       
 
       
    const channelsValue = useContext(ChannelsContext);

     

       
26
       
 
       
    if (!channelsValue)

     

       
27
       
 
       
        throw new Error(

     

       
28
       
+
       
            "Channels context was null. Did you try to access this outside of the authed providers? ChannelsProvider must be below MembershipsProvider.",

     

       
29
       
 
       
        );

     

       
30
       
 
       
    return channelsValue;

     

       
31
       
 
       
};

     

···

       
19
       
 
       
import type { ReactNode } from "react";

     

       
20
       
 
       
import { createContext, useContext, useMemo } from "react";

     

       
21
       
 
       


     

       
22
       
-
       
type LatticeSessionsMap = Map<Did, LatticeSessionInfo>;

     

       
23
       
 
       


     

       
24
       
-
       
interface LatticeSessionContextValue {

     

       
25
       
-
       
    sessions: LatticeSessionsMap;

     

       
26
       
 
       
    isInitialising: boolean;

     

       
27
       
 
       
    error: Error | null;

     

       
28
       
-
       
    getSession: (latticeDid: Did) => LatticeSessionInfo | undefined;

     

       
29
       
 
       
}

     

       
30
       
 
       


     

       
31
       
-
       
const LatticeSessionsContext = createContext<LatticeSessionContextValue | null>(

     

       
32
       
-
       
    null,

     

       
33
       
-
       
);

     

       
34
       
 
       


     

       
35
       
-
       
export const useLatticeSession = () => {

     

       
36
       
-
       
    const value = useContext(LatticeSessionsContext);

     

       
37
       
-
       
    if (value === null)

     

       
38
       
 
       
        throw new Error(

     

       
39
       
-
       
            "Lattice session context not inited. Or ordering of providers was wrong.",

     

       
40
       
 
       
        );

     

       
41
       
-
       
    return value.sessions;

     

       
42
       
 
       
};

     

       
43
       
 
       


     

       
44
       
-
       
const LatticeSessionsProviderInner = ({

     

       
45
       
-
       
    children,

     

       
46
       
-
       
}: {

     

       
47
       
-
       
    children: ReactNode;

     

       
48
       
-
       
}) => {

     

       
49
       
 
       
    const {

     

       
50
       
 
       
        memberships,

     

       
51
       
 
       
        isInitialising: membershipsInitialising,

     
···

       
64
       
 
       
            "LatticeSessionsProvider must be used within an OAuth provider.",

     

       
65
       
 
       
        );

     

       
66
       
 
       


     

       
67
       
-
       
    const { session, isLoading, agent, client } = oauth;

     

       
68
       
-
       
    const isOAuthReady = !isLoading && !!agent && !!client && !!session;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
69
       
 
       


     

       
70
       
 
       
    const handshakeQueries = useQueries({

     

       
71
       
 
       
        queries: channels.map((channelObj) => ({

     
···

       
94
       
 
       
        handshakeQueries.find((q) => q.error)?.error ??

     

       
95
       
 
       
        null;

     

       
96
       
 
       


     

       
97
       
-
       
    const sessions = useMemo(() => {

     

       
98
       
-
       
        const sessionsMap = new Map<Did, LatticeSessionInfo>();

     

       
99
       
 
       
        handshakeQueries.forEach((queryResult) => {

     

       
100
       
 
       
            if (queryResult.data) {

     

       
101
       
 
       
                const { did, sessionInfo } = queryResult.data;

     

       
102
       
-
       
                sessionsMap.set(did, sessionInfo);

     

       
103
       
 
       
            }

     

       
104
       
 
       
        });

     

       
105
       
-
       
        return sessionsMap;

     

       
106
       
 
       
    }, [handshakeQueries]);

     

       
107
       
 
       


     

       
108
       
-
       
    const value: LatticeSessionContextValue = {

     

       
109
       
 
       
        isInitialising,

     

       
110
       
 
       
        error,

     

       
111
       
-
       
        sessions,

     

       
112
       
-
       
        getSession: (latticeDid) => sessions.get(latticeDid),

     

       
113
       
 
       
    };

     

       
114
       
 
       


     

       
115
       
-
       
    return (

     

       
116
       
-
       
        <LatticeSessionsContext value={value}>

     

       
117
       
-
       
            {children}

     

       
118
       
-
       
        </LatticeSessionsContext>

     

       
119
       
-
       
    );

     

       
120
       
 
       
};

     

       
121
       
 
       


     

       
122
       
 
       
const handshakesQueryFn = async ({

     
···

       
163
       
 
       
    };

     

       
164
       
 
       
};

     

       
165
       
 
       


     

       
166
       
-
       
export const LatticeSessionsProvider = ({

     

       
167
       
-
       
    children,

     

       
168
       
-
       
}: {

     

       
169
       
-
       
    children: ReactNode;

     

       
170
       
-
       
}) => {

     

       
171
       
 
       
    // Memberships must be above channels

     

       
172
       
 
       
    // channels must be above lattice sessions inner

     

       
173
       
 
       
    // do it this way to preserve the order if we need to move them around some day

     

       
174
       
 
       
    return (

     

       
175
       
 
       
        <MembershipsProvider>

     

       
176
       
 
       
            <ChannelsProvider>

     

       
177
       
-
       
                <LatticeSessionsProviderInner>

     

       
178
       
-
       
                    {children}

     

       
179
       
-
       
                </LatticeSessionsProviderInner>

     

       
180
       
 
       
            </ChannelsProvider>

     

       
181
       
 
       
        </MembershipsProvider>

     

       
182
       
 
       
    );

     

···

       
19
       
 
       
import type { ReactNode } from "react";

     

       
20
       
 
       
import { createContext, useContext, useMemo } from "react";

     

       
21
       
 
       


     

       
22
       
+
       
type HandshakesMap = Map<Did, LatticeSessionInfo>;

     

       
23
       
 
       


     

       
24
       
+
       
interface HandshakeContextValue {

     

       
25
       
+
       
    handshakesMap: HandshakesMap;

     

       
26
       
 
       
    isInitialising: boolean;

     

       
27
       
 
       
    error: Error | null;

     

       
28
       
+
       
    getHandshake: (latticeDid: Did) => LatticeSessionInfo | undefined;

     

       
29
       
 
       
}

     

       
30
       
 
       


     

       
31
       
+
       
const HandshakesContext = createContext<HandshakeContextValue | null>(null);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
32
       
 
       


     

       
33
       
+
       
export const useHandshakes = () => {

     

       
34
       
+
       
    const handshakesValue = useContext(HandshakesContext);

     

       
35
       
+
       
    if (!handshakesValue)

     

       
36
       
 
       
        throw new Error(

     

       
37
       
+
       
            "Handshakes context was null. Did you try to access this outside of the authed providers? HandshakesProvider(Inner) must be below ChannelsProvider.",

     

       
38
       
 
       
        );

     

       
39
       
+
       
    return handshakesValue;

     

       
40
       
 
       
};

     

       
41
       
 
       


     

       
42
       
+
       
const HandshakesProviderInner = ({ children }: { children: ReactNode }) => {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
43
       
 
       
    const {

     

       
44
       
 
       
        memberships,

     

       
45
       
 
       
        isInitialising: membershipsInitialising,

     
···

       
58
       
 
       
            "LatticeSessionsProvider must be used within an OAuth provider.",

     

       
59
       
 
       
        );

     

       
60
       
 
       


     

       
61
       
+
       
    const {

     

       
62
       
+
       
        session: oAuthSession,

     

       
63
       
+
       
        isLoading: isOauthLoading,

     

       
64
       
+
       
        agent: oAuthAgent,

     

       
65
       
+
       
        client: oAuthClient,

     

       
66
       
+
       
    } = oauth;

     

       
67
       
+
       
    const isOAuthReady =

     

       
68
       
+
       
        !isOauthLoading && !!oAuthAgent && !!oAuthClient && !!oAuthSession;

     

       
69
       
 
       


     

       
70
       
 
       
    const handshakeQueries = useQueries({

     

       
71
       
 
       
        queries: channels.map((channelObj) => ({

     
···

       
94
       
 
       
        handshakeQueries.find((q) => q.error)?.error ??

     

       
95
       
 
       
        null;

     

       
96
       
 
       


     

       
97
       
+
       
    const handshakes = useMemo(() => {

     

       
98
       
+
       
        const handshakesMap = new Map<Did, LatticeSessionInfo>();

     

       
99
       
 
       
        handshakeQueries.forEach((queryResult) => {

     

       
100
       
 
       
            if (queryResult.data) {

     

       
101
       
 
       
                const { did, sessionInfo } = queryResult.data;

     

       
102
       
+
       
                handshakesMap.set(did, sessionInfo);

     

       
103
       
 
       
            }

     

       
104
       
 
       
        });

     

       
105
       
+
       
        return handshakesMap;

     

       
106
       
 
       
    }, [handshakeQueries]);

     

       
107
       
 
       


     

       
108
       
+
       
    const value: HandshakeContextValue = {

     

       
109
       
 
       
        isInitialising,

     

       
110
       
 
       
        error,

     

       
111
       
+
       
        handshakesMap: handshakes,

     

       
112
       
+
       
        getHandshake: (latticeDid) => handshakes.get(latticeDid),

     

       
113
       
 
       
    };

     

       
114
       
 
       


     

       
115
       
+
       
    return <HandshakesContext value={value}>{children}</HandshakesContext>;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
116
       
 
       
};

     

       
117
       
 
       


     

       
118
       
 
       
const handshakesQueryFn = async ({

     
···

       
159
       
 
       
    };

     

       
160
       
 
       
};

     

       
161
       
 
       


     

       
162
       
+
       
export const HandshakesProvider = ({ children }: { children: ReactNode }) => {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
163
       
 
       
    // Memberships must be above channels

     

       
164
       
 
       
    // channels must be above lattice sessions inner

     

       
165
       
 
       
    // do it this way to preserve the order if we need to move them around some day

     

       
166
       
 
       
    return (

     

       
167
       
 
       
        <MembershipsProvider>

     

       
168
       
 
       
            <ChannelsProvider>

     

       
169
       
+
       
                <HandshakesProviderInner>{children}</HandshakesProviderInner>

     

       
0
       
 
       

     

       
0
       
 
       

     

       
170
       
 
       
            </ChannelsProvider>

     

       
171
       
 
       
        </MembershipsProvider>

     

       
172
       
 
       
    );

     

···

       
24
       
 
       
    const membershipsValue = useContext(MembershipsContext);

     

       
25
       
 
       
    if (!membershipsValue)

     

       
26
       
 
       
        throw new Error(

     

       
27
       
-
       
            "Memberships context was null. Did you try to access this outside of the authed providers? MembershipsProvider must be below OAuth provider.",

     

       
28
       
 
       
        );

     

       
29
       
 
       
    return membershipsValue;

     

       
30
       
 
       
};

     

···

       
24
       
 
       
    const membershipsValue = useContext(MembershipsContext);

     

       
25
       
 
       
    if (!membershipsValue)

     

       
26
       
 
       
        throw new Error(

     

       
27
       
+
       
            "Memberships context was null. Did you try to access this outside of the authed providers? MembershipsProvider must be below OAuthProvider.",

     

       
28
       
 
       
        );

     

       
29
       
 
       
    return membershipsValue;

     

       
30
       
 
       
};

     

···

       
1
       
-
       
import { LatticeSessionsProvider } from "@/providers/authed/LatticeSessionsProvider";

     

       
2
       
 
       
import type { ReactNode } from "react";

     

       
3
       
 
       


     

       
4
       
 
       
export const AuthedProviders = ({ children }: { children: ReactNode }) => {

     

       
5
       
-
       
    return <LatticeSessionsProvider>{children}</LatticeSessionsProvider>;

     

       
6
       
 
       
};

     

···

       
1
       
+
       
import { HandshakesProvider } from "@/providers/authed/HandshakesProvider";

     

       
2
       
 
       
import type { ReactNode } from "react";

     

       
3
       
 
       


     

       
4
       
 
       
export const AuthedProviders = ({ children }: { children: ReactNode }) => {

     

       
5
       
+
       
    return <HandshakesProvider>{children}</HandshakesProvider>;

     

       
6
       
 
       
};