···

       
63
       
 
       
        const recordResult = await getRecordFromFullAtUri(inviteAtUri);

     

       
64
       
 
       
        if (!recordResult.ok) {

     

       
65
       
 
       
            console.error(

     

       
66
       
-
       
                `something went wrong fetching the record from the given membership ${JSON.stringify(membership)}`,

     

       
67
       
 
       
            );

     

       
68
       
 
       
            throw new Error(

     

       
69
       
 
       
                JSON.stringify({ error: recordResult.error, membership }),

     
···

       
78
       
 
       
    } catch (err) {

     

       
79
       
 
       
        return newErrorResponse(500, {

     

       
80
       
 
       
            message:

     

       
81
       
-
       
                "Something went wrong when fetching membership channel records. Check the Shard logs if possible.",

     

       
82
       
 
       
            details: err,

     

       
83
       
 
       
        });

     

       
84
       
 
       
    }

     
···

       
115
       
 
       
            const recordResult = await getRecordFromFullAtUri(channelAtUri);

     

       
116
       
 
       
            if (!recordResult.ok) {

     

       
117
       
 
       
                console.error(

     

       
118
       
-
       
                    `something went wrong fetching the record from the given membership ${JSON.stringify(invite)}`,

     

       
119
       
 
       
                );

     

       
120
       
 
       
                throw new Error(

     

       
121
       
 
       
                    JSON.stringify({ error: recordResult.error, invite }),

     
···

       
158
       
 
       
    // did of the backlink. if there are any channels described by unauthorised parties, simply drop them.

     

       
159
       
 
       


     

       
160
       
 
       
    let mismatchOrIncorrect = false;

     

       
0
       
 
       

     

       
161
       
 
       
    const existingShardConnectionShardDids = shardSessions

     

       
162
       
 
       
        .keys()

     

       
163
       
 
       
        .toArray()

     
···

       
175
       
 
       
            routeThroughRecord.uri,

     

       
176
       
 
       
        );

     

       
177
       
 
       
        if (!routeThroughRecordParseResult.ok) {

     

       
0
       
 
       

     

       
178
       
 
       
            mismatchOrIncorrect = true;

     

       
179
       
 
       
            return;

     

       
180
       
 
       
        }

     
···

       
183
       
 
       
        // FIXME: this also assumes that the requesting lattice's DID is a did:web

     

       
184
       
 
       
        // see below for the rest of the issues.

     

       
185
       
 
       
        if (routeThroughUri.rKey === SERVICE_DID.slice(8)) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
186
       
 
       
            mismatchOrIncorrect = true;

     

       
187
       
 
       
            return;

     

       
188
       
 
       
        }

     

       
189
       
 
       
        const storeAtRecordParseResult = stringToAtUri(storeAtRecord.uri);

     

       
190
       
 
       
        if (!storeAtRecordParseResult.ok) {

     

       
0
       
 
       

     

       
191
       
 
       
            mismatchOrIncorrect = true;

     

       
192
       
 
       
            return;

     

       
193
       
 
       
        }

     
···

       
203
       
 
       
        if (!storeAtUri.rKey) return;

     

       
204
       
 
       


     

       
205
       
 
       
        if (!existingShardConnectionShardDids.includes(storeAtUri.rKey)) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
206
       
 
       
            mismatchOrIncorrect = true;

     

       
207
       
 
       
            return;

     

       
208
       
 
       
        }

     
···

       
213
       
 
       
        return newErrorResponse(400, {

     

       
214
       
 
       
            message:

     

       
215
       
 
       
                "Channels provided during the handshake had a mismatch between the channel values. Ensure that you are only submitting exactly the channels you have access to.",

     

       
0
       
 
       

     

       
216
       
 
       
        });

     

       
217
       
 
       


     

       
218
       
 
       
    // yipee, it's a valid request :3

     

···

       
63
       
 
       
        const recordResult = await getRecordFromFullAtUri(inviteAtUri);

     

       
64
       
 
       
        if (!recordResult.ok) {

     

       
65
       
 
       
            console.error(

     

       
66
       
+
       
                `something went wrong fetching the invite record from the given membership ${JSON.stringify(membership)}`,

     

       
67
       
 
       
            );

     

       
68
       
 
       
            throw new Error(

     

       
69
       
 
       
                JSON.stringify({ error: recordResult.error, membership }),

     
···

       
78
       
 
       
    } catch (err) {

     

       
79
       
 
       
        return newErrorResponse(500, {

     

       
80
       
 
       
            message:

     

       
81
       
+
       
                "Something went wrong when fetching membership invite records. Check the Shard logs if possible.",

     

       
82
       
 
       
            details: err,

     

       
83
       
 
       
        });

     

       
84
       
 
       
    }

     
···

       
115
       
 
       
            const recordResult = await getRecordFromFullAtUri(channelAtUri);

     

       
116
       
 
       
            if (!recordResult.ok) {

     

       
117
       
 
       
                console.error(

     

       
118
       
+
       
                    `something went wrong fetching the channel record from the given membership ${JSON.stringify(invite)}`,

     

       
119
       
 
       
                );

     

       
120
       
 
       
                throw new Error(

     

       
121
       
 
       
                    JSON.stringify({ error: recordResult.error, invite }),

     
···

       
158
       
 
       
    // did of the backlink. if there are any channels described by unauthorised parties, simply drop them.

     

       
159
       
 
       


     

       
160
       
 
       
    let mismatchOrIncorrect = false;

     

       
161
       
+
       
    const errors: Array<unknown> = [];

     

       
162
       
 
       
    const existingShardConnectionShardDids = shardSessions

     

       
163
       
 
       
        .keys()

     

       
164
       
 
       
        .toArray()

     
···

       
176
       
 
       
            routeThroughRecord.uri,

     

       
177
       
 
       
        );

     

       
178
       
 
       
        if (!routeThroughRecordParseResult.ok) {

     

       
179
       
+
       
            errors.push(routeThroughRecordParseResult.error);

     

       
180
       
 
       
            mismatchOrIncorrect = true;

     

       
181
       
 
       
            return;

     

       
182
       
 
       
        }

     
···

       
185
       
 
       
        // FIXME: this also assumes that the requesting lattice's DID is a did:web

     

       
186
       
 
       
        // see below for the rest of the issues.

     

       
187
       
 
       
        if (routeThroughUri.rKey === SERVICE_DID.slice(8)) {

     

       
188
       
+
       
            errors.push(

     

       
189
       
+
       
                "Mismatch between claimant lattice and channel routeThrough. Request wants to validate for",

     

       
190
       
+
       
                routeThroughUri.rKey,

     

       
191
       
+
       
                ", but this lattice is",

     

       
192
       
+
       
                SERVICE_DID.slice(8),

     

       
193
       
+
       
            );

     

       
194
       
 
       
            mismatchOrIncorrect = true;

     

       
195
       
 
       
            return;

     

       
196
       
 
       
        }

     

       
197
       
 
       
        const storeAtRecordParseResult = stringToAtUri(storeAtRecord.uri);

     

       
198
       
 
       
        if (!storeAtRecordParseResult.ok) {

     

       
199
       
+
       
            errors.push(storeAtRecordParseResult.error);

     

       
200
       
 
       
            mismatchOrIncorrect = true;

     

       
201
       
 
       
            return;

     

       
202
       
 
       
        }

     
···

       
212
       
 
       
        if (!storeAtUri.rKey) return;

     

       
213
       
 
       


     

       
214
       
 
       
        if (!existingShardConnectionShardDids.includes(storeAtUri.rKey)) {

     

       
215
       
+
       
            errors.push(

     

       
216
       
+
       
                "Mismatch between claimant shard and channel storeAt. Request wants to validate for",

     

       
217
       
+
       
                storeAtUri.rKey,

     

       
218
       
+
       
                ", but this lattice is only allowed to talk to",

     

       
219
       
+
       
                existingShardConnectionShardDids,

     

       
220
       
+
       
            );

     

       
221
       
 
       
            mismatchOrIncorrect = true;

     

       
222
       
 
       
            return;

     

       
223
       
 
       
        }

     
···

       
228
       
 
       
        return newErrorResponse(400, {

     

       
229
       
 
       
            message:

     

       
230
       
 
       
                "Channels provided during the handshake had a mismatch between the channel values. Ensure that you are only submitting exactly the channels you have access to.",

     

       
231
       
+
       
            details: errors,

     

       
232
       
 
       
        });

     

       
233
       
 
       


     

       
234
       
 
       
    // yipee, it's a valid request :3