commit 068dc42c90f07de9010f6d368a90628cec57f232 · gmstn.systems/shard

+23 -2
src/lib/handlers/handshake.ts
···

       33
       33
        
               handshakeData;

     

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

     

       35
       35
        
               const res = stringToAtUri(channel);

     

       36
       36
       -
               if (!res.ok) return;

     

       36
       36
       +
               if (!res.ok) {

     

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

     

       38
       38
       +
                   return;

     

       39
       39
       +
               }

     

       37
       40
        
               return res.data;

     

       38
       41
        
           });

     

       39
       42
        
       

     

       40
       43
        
           const verifyJwtResult = await verifyServiceJwt(interServiceJwt);

     

       41
       44
        
           if (!verifyJwtResult.ok) {

     

       42
       45
        
               const { error } = verifyJwtResult;

     

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

     

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

     

       43
       48
        
               return newErrorResponse(

     

       44
       49
        
                   401,

     

       45
       50
        
                   {

     
···

       70
       75
        
           });

     

       71
       76
        
           if (!constellationResponse.ok) {

     

       72
       77
        
               const { error } = constellationResponse;

     

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

     

       73
       79
        
               if ("fetchStatus" in error)

     

       74
       80
        
                   return newErrorResponse(error.fetchStatus, {

     

       75
       81
        
                       message:

     
···

       102
       108
        
           try {

     

       103
       109
        
               pdsChannelRecords = await Promise.all(pdsRecordFetchPromises);

     

       104
       110
        
           } catch (err) {

     

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

     

       105
       112
        
               return newErrorResponse(500, {

     

       106
       113
        
                   message:

     

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

     
···

       117
       124
        
               .array(systemsGmstnDevelopmentChannelRecordSchema)

     

       118
       125
        
               .safeParse(pdsChannelRecords);

     

       119
       126
        
           if (!channelRecordsParseSuccess) {

     

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

     

       120
       128
        
               return newErrorResponse(500, {

     

       121
       129
        
                   message:

     

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

     
···

       132
       140
        
       

     

       133
       141
        
           let mismatchOrIncorrect = false;

     

       134
       142
        
           const requestingLatticeDid = verifyJwtResult.value.issuer;

     

       143
       143
       +
           let mismatchReason = "";

     

       135
       144
        
       

     

       136
       145
        
           channelRecordsParsed.forEach((channel) => {

     

       137
       146
        
               if (mismatchOrIncorrect) return;

     
···

       141
       150
        
               const storeAtRecordParseResult = stringToAtUri(storeAtRecord.uri);

     

       142
       151
        
               if (!storeAtRecordParseResult.ok) {

     

       143
       152
        
                   mismatchOrIncorrect = true;

     

       153
       153
       +
                   mismatchReason =

     

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

     

       155
       155
       +
                       JSON.stringify(storeAtRecordParseResult.error);

     

       144
       156
        
                   return;

     

       145
       157
        
               }

     

       146
       158
        
               const storeAtUri = storeAtRecordParseResult.data;

     
···

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

     

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

     

       155
       167
        
                   mismatchOrIncorrect = true;

     

       168
       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 ?? ""}`;

     

       156
       169
        
                   return;

     

       157
       170
        
               }

     

       158
       171
        
       

     
···

       160
       173
        
                   routeThroughRecord.uri,

     

       161
       174
        
               );

     

       162
       175
        
               if (!routeThroughRecordParseResult.ok) {

     

       176
       176
       +
                   mismatchReason =

     

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

     

       178
       178
       +
                       JSON.stringify(routeThroughRecordParseResult.error);

     

       163
       179
        
                   mismatchOrIncorrect = true;

     

       164
       180
        
                   return;

     

       165
       181
        
               }

     
···

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

     

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

     

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

     

       187
       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 ?? ""}`;

     

       171
       188
        
                   mismatchOrIncorrect = true;

     

       172
       189
        
                   return;

     

       173
       190
        
               }

     

       174
       191
        
           });

     

       175
       192
        
       

     

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

     

       177
       177
       -
           if (mismatchOrIncorrect)

     

       194
       194
       +
           if (mismatchOrIncorrect) {

     

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

     

       196
       196
       +
               console.log(mismatchReason)

     

       178
       197
        
               return newErrorResponse(400, {

     

       179
       198
        
                   message:

     

       180
       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
       200
       +
                   details: mismatchReason,

     

       181
       201
        
               });

     

       202
       202
       +
           }

     

       182
       203
        
       

     

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

     

       184
       205