···

       
33
       
 
       
        handshakeData;

     

       
34
       
 
       
    const allowedChannels = channelAtUriStrings.map((channel) => {

     

       
35
       
 
       
        const res = stringToAtUri(channel);

     

       
36
       
-
       
        if (!res.ok) return;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
37
       
 
       
        return res.data;

     

       
38
       
 
       
    });

     

       
39
       
 
       


     

       
40
       
 
       
    const verifyJwtResult = await verifyServiceJwt(interServiceJwt);

     

       
41
       
 
       
    if (!verifyJwtResult.ok) {

     

       
42
       
 
       
        const { error } = verifyJwtResult;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
43
       
 
       
        return newErrorResponse(

     

       
44
       
 
       
            401,

     

       
45
       
 
       
            {

     
···

       
70
       
 
       
    });

     

       
71
       
 
       
    if (!constellationResponse.ok) {

     

       
72
       
 
       
        const { error } = constellationResponse;

     

       
0
       
 
       

     

       
73
       
 
       
        if ("fetchStatus" in error)

     

       
74
       
 
       
            return newErrorResponse(error.fetchStatus, {

     

       
75
       
 
       
                message:

     
···

       
102
       
 
       
    try {

     

       
103
       
 
       
        pdsChannelRecords = await Promise.all(pdsRecordFetchPromises);

     

       
104
       
 
       
    } catch (err) {

     

       
0
       
 
       

     

       
105
       
 
       
        return newErrorResponse(500, {

     

       
106
       
 
       
            message:

     

       
107
       
 
       
                "Something went wrong when fetching backlink channel records. Check the Shard logs if possible.",

     
···

       
117
       
 
       
        .array(systemsGmstnDevelopmentChannelRecordSchema)

     

       
118
       
 
       
        .safeParse(pdsChannelRecords);

     

       
119
       
 
       
    if (!channelRecordsParseSuccess) {

     

       
0
       
 
       

     

       
120
       
 
       
        return newErrorResponse(500, {

     

       
121
       
 
       
            message:

     

       
122
       
 
       
                "One of the backlinks returned by Constellation did not resolve to a proper lexicon Channel record.",

     
···

       
132
       
 
       


     

       
133
       
 
       
    let mismatchOrIncorrect = false;

     

       
134
       
 
       
    const requestingLatticeDid = verifyJwtResult.value.issuer;

     

       
0
       
 
       

     

       
135
       
 
       


     

       
136
       
 
       
    channelRecordsParsed.forEach((channel) => {

     

       
137
       
 
       
        if (mismatchOrIncorrect) return;

     
···

       
141
       
 
       
        const storeAtRecordParseResult = stringToAtUri(storeAtRecord.uri);

     

       
142
       
 
       
        if (!storeAtRecordParseResult.ok) {

     

       
143
       
 
       
            mismatchOrIncorrect = true;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
144
       
 
       
            return;

     

       
145
       
 
       
        }

     

       
146
       
 
       
        const storeAtUri = storeAtRecordParseResult.data;

     
···

       
153
       
 
       
        // we should probably just resolve this properly first but for now, i cba.

     

       
154
       
 
       
        if (storeAtUri.rKey !== SERVICE_DID.slice(8)) {

     

       
155
       
 
       
            mismatchOrIncorrect = true;

     

       
0
       
 
       

     

       
156
       
 
       
            return;

     

       
157
       
 
       
        }

     

       
158
       
 
       


     
···

       
160
       
 
       
            routeThroughRecord.uri,

     

       
161
       
 
       
        );

     

       
162
       
 
       
        if (!routeThroughRecordParseResult.ok) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
163
       
 
       
            mismatchOrIncorrect = true;

     

       
164
       
 
       
            return;

     

       
165
       
 
       
        }

     
···

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

     

       
169
       
 
       
        // see above for the rest of the issues.

     

       
170
       
 
       
        if (routeThroughUri.rKey === requestingLatticeDid.slice(8)) {

     

       
0
       
 
       

     

       
171
       
 
       
            mismatchOrIncorrect = true;

     

       
172
       
 
       
            return;

     

       
173
       
 
       
        }

     

       
174
       
 
       
    });

     

       
175
       
 
       


     

       
176
       
 
       
    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition

     

       
177
       
-
       
    if (mismatchOrIncorrect)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
178
       
 
       
        return newErrorResponse(400, {

     

       
179
       
 
       
            message:

     

       
180
       
 
       
                "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
       
 
       

     

       
181
       
 
       
        });

     

       
0
       
 
       

     

       
182
       
 
       


     

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

     

       
184
       
 
       


     

···

       
33
       
 
       
        handshakeData;

     

       
34
       
 
       
    const allowedChannels = channelAtUriStrings.map((channel) => {

     

       
35
       
 
       
        const res = stringToAtUri(channel);

     

       
36
       
+
       
        if (!res.ok) {

     

       
37
       
+
       
            console.error(JSON.stringify(res.error));

     

       
38
       
+
       
            return;

     

       
39
       
+
       
        }

     

       
40
       
 
       
        return res.data;

     

       
41
       
 
       
    });

     

       
42
       
 
       


     

       
43
       
 
       
    const verifyJwtResult = await verifyServiceJwt(interServiceJwt);

     

       
44
       
 
       
    if (!verifyJwtResult.ok) {

     

       
45
       
 
       
        const { error } = verifyJwtResult;

     

       
46
       
+
       
        console.log("Could not verify service JWT");

     

       
47
       
+
       
        console.log(JSON.stringify(error));

     

       
48
       
 
       
        return newErrorResponse(

     

       
49
       
 
       
            401,

     

       
50
       
 
       
            {

     
···

       
75
       
 
       
    });

     

       
76
       
 
       
    if (!constellationResponse.ok) {

     

       
77
       
 
       
        const { error } = constellationResponse;

     

       
78
       
+
       
        console.log("Constellation errored out", JSON.stringify(error));

     

       
79
       
 
       
        if ("fetchStatus" in error)

     

       
80
       
 
       
            return newErrorResponse(error.fetchStatus, {

     

       
81
       
 
       
                message:

     
···

       
108
       
 
       
    try {

     

       
109
       
 
       
        pdsChannelRecords = await Promise.all(pdsRecordFetchPromises);

     

       
110
       
 
       
    } catch (err) {

     

       
111
       
+
       
        console.log(JSON.stringify(err));

     

       
112
       
 
       
        return newErrorResponse(500, {

     

       
113
       
 
       
            message:

     

       
114
       
 
       
                "Something went wrong when fetching backlink channel records. Check the Shard logs if possible.",

     
···

       
124
       
 
       
        .array(systemsGmstnDevelopmentChannelRecordSchema)

     

       
125
       
 
       
        .safeParse(pdsChannelRecords);

     

       
126
       
 
       
    if (!channelRecordsParseSuccess) {

     

       
127
       
+
       
        console.log(JSON.stringify(z.treeifyError(channelRecordsParseError)));

     

       
128
       
 
       
        return newErrorResponse(500, {

     

       
129
       
 
       
            message:

     

       
130
       
 
       
                "One of the backlinks returned by Constellation did not resolve to a proper lexicon Channel record.",

     
···

       
140
       
 
       


     

       
141
       
 
       
    let mismatchOrIncorrect = false;

     

       
142
       
 
       
    const requestingLatticeDid = verifyJwtResult.value.issuer;

     

       
143
       
+
       
    let mismatchReason = "";

     

       
144
       
 
       


     

       
145
       
 
       
    channelRecordsParsed.forEach((channel) => {

     

       
146
       
 
       
        if (mismatchOrIncorrect) return;

     
···

       
150
       
 
       
        const storeAtRecordParseResult = stringToAtUri(storeAtRecord.uri);

     

       
151
       
 
       
        if (!storeAtRecordParseResult.ok) {

     

       
152
       
 
       
            mismatchOrIncorrect = true;

     

       
153
       
+
       
            mismatchReason =

     

       
154
       
+
       
                "could not parse store at record into at uri object," +

     

       
155
       
+
       
                JSON.stringify(storeAtRecordParseResult.error);

     

       
156
       
 
       
            return;

     

       
157
       
 
       
        }

     

       
158
       
 
       
        const storeAtUri = storeAtRecordParseResult.data;

     
···

       
165
       
 
       
        // we should probably just resolve this properly first but for now, i cba.

     

       
166
       
 
       
        if (storeAtUri.rKey !== SERVICE_DID.slice(8)) {

     

       
167
       
 
       
            mismatchOrIncorrect = true;

     

       
168
       
+
       
            mismatchReason = `store at record domain did not match with this shard. this shard's domain is ${SERVICE_DID.slice(8)}, the domain on the record is ${storeAtUri.rKey ?? ""}`;

     

       
169
       
 
       
            return;

     

       
170
       
 
       
        }

     

       
171
       
 
       


     
···

       
173
       
 
       
            routeThroughRecord.uri,

     

       
174
       
 
       
        );

     

       
175
       
 
       
        if (!routeThroughRecordParseResult.ok) {

     

       
176
       
+
       
            mismatchReason =

     

       
177
       
+
       
                "could not parse route through record into at uri object," +

     

       
178
       
+
       
                JSON.stringify(routeThroughRecordParseResult.error);

     

       
179
       
 
       
            mismatchOrIncorrect = true;

     

       
180
       
 
       
            return;

     

       
181
       
 
       
        }

     
···

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

     

       
185
       
 
       
        // see above for the rest of the issues.

     

       
186
       
 
       
        if (routeThroughUri.rKey === requestingLatticeDid.slice(8)) {

     

       
187
       
+
       
            mismatchReason = `route through record domain did not match with requesting service. the requesting service's domain is ${SERVICE_DID.slice(8)}, the domain on the record is ${storeAtUri.rKey ?? ""}`;

     

       
188
       
 
       
            mismatchOrIncorrect = true;

     

       
189
       
 
       
            return;

     

       
190
       
 
       
        }

     

       
191
       
 
       
    });

     

       
192
       
 
       


     

       
193
       
 
       
    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition

     

       
194
       
+
       
    if (mismatchOrIncorrect) {

     

       
195
       
+
       
        console.log("Channels mismatched.");

     

       
196
       
+
       
        console.log(mismatchReason)

     

       
197
       
 
       
        return newErrorResponse(400, {

     

       
198
       
 
       
            message:

     

       
199
       
 
       
                "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.",

     

       
200
       
+
       
            details: mismatchReason,

     

       
201
       
 
       
        });

     

       
202
       
+
       
    }

     

       
203
       
 
       


     

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

     

       
205