commit 9e91191bbe60361723eae1f4436273f5360b7bb7 · edouard.paris/did-method-plc

.github/workflows/build-and-push-aws.yaml

···

       11
       11
        
       

     

       12
       12
        
       jobs:

     

       13
       13
        
         plc-container-aws:

     

       14
       14
       +
           if: github.repository == 'bluesky-social/did-method-plc'

     

       14
       15
        
           runs-on: ubuntu-latest

     

       15
       16
        
           permissions:

     

       16
       17
        
             contents: read

.github/workflows/build-and-push-ghcr.yaml

···

       12
       12
        
       

     

       13
       13
        
       jobs:

     

       14
       14
        
         plc-container-ghcr:

     

       15
       15
       +
           if: github.repository == 'bluesky-social/did-method-plc'

     

       15
       16
        
           runs-on: ubuntu-latest

     

       16
       17
        
           permissions:

     

       17
       18
        
             contents: read

+3 -19

LICENSE

···

       1
       1
       -
       MIT License

     

       2
       2
       -
       

     

       3
       3
       -
       Copyright (c) 2022-2023 Bluesky PBLLC

     

       4
       4
       -
       

     

       5
       5
       -
       Permission is hereby granted, free of charge, to any person obtaining a copy

     

       6
       6
       -
       of this software and associated documentation files (the "Software"), to deal

     

       7
       7
       -
       in the Software without restriction, including without limitation the rights

     

       8
       8
       -
       to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

     

       9
       9
       -
       copies of the Software, and to permit persons to whom the Software is

     

       10
       10
       -
       furnished to do so, subject to the following conditions:

     

       1
       1
       +
       Dual MIT/Apache-2.0 License

     

       11
       2
        
       

     

       12
       12
       -
       The above copyright notice and this permission notice shall be included in all

     

       13
       13
       -
       copies or substantial portions of the Software.

     

       3
       3
       +
       Copyright (c) 2022-2023 Bluesky PBC

     

       14
       4
        
       

     

       15
       15
       -
       THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

     

       16
       16
       -
       IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

     

       17
       17
       -
       FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

     

       18
       18
       -
       AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

     

       19
       19
       -
       LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

     

       20
       20
       -
       OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

     

       21
       21
       -
       SOFTWARE.

     

       5
       5
       +
       Except as otherwise noted in individual files, this software is licensed under the MIT license (<http://opensource.org/licenses/MIT>), or the Apache License, Version 2.0 (<http://www.apache.org/licenses/LICENSE-2.0>), at your option.

+202

LICENSE-APACHE

···

       1
       1
       +
       

     

       2
       2
       +
                                        Apache License

     

       3
       3
       +
                                  Version 2.0, January 2004

     

       4
       4
       +
                               http://www.apache.org/licenses/

     

       5
       5
       +
       

     

       6
       6
       +
          TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

     

       7
       7
       +
       

     

       8
       8
       +
          1. Definitions.

     

       9
       9
       +
       

     

       10
       10
       +
             "License" shall mean the terms and conditions for use, reproduction,

     

       11
       11
       +
             and distribution as defined by Sections 1 through 9 of this document.

     

       12
       12
       +
       

     

       13
       13
       +
             "Licensor" shall mean the copyright owner or entity authorized by

     

       14
       14
       +
             the copyright owner that is granting the License.

     

       15
       15
       +
       

     

       16
       16
       +
             "Legal Entity" shall mean the union of the acting entity and all

     

       17
       17
       +
             other entities that control, are controlled by, or are under common

     

       18
       18
       +
             control with that entity. For the purposes of this definition,

     

       19
       19
       +
             "control" means (i) the power, direct or indirect, to cause the

     

       20
       20
       +
             direction or management of such entity, whether by contract or

     

       21
       21
       +
             otherwise, or (ii) ownership of fifty percent (50%) or more of the

     

       22
       22
       +
             outstanding shares, or (iii) beneficial ownership of such entity.

     

       23
       23
       +
       

     

       24
       24
       +
             "You" (or "Your") shall mean an individual or Legal Entity

     

       25
       25
       +
             exercising permissions granted by this License.

     

       26
       26
       +
       

     

       27
       27
       +
             "Source" form shall mean the preferred form for making modifications,

     

       28
       28
       +
             including but not limited to software source code, documentation

     

       29
       29
       +
             source, and configuration files.

     

       30
       30
       +
       

     

       31
       31
       +
             "Object" form shall mean any form resulting from mechanical

     

       32
       32
       +
             transformation or translation of a Source form, including but

     

       33
       33
       +
             not limited to compiled object code, generated documentation,

     

       34
       34
       +
             and conversions to other media types.

     

       35
       35
       +
       

     

       36
       36
       +
             "Work" shall mean the work of authorship, whether in Source or

     

       37
       37
       +
             Object form, made available under the License, as indicated by a

     

       38
       38
       +
             copyright notice that is included in or attached to the work

     

       39
       39
       +
             (an example is provided in the Appendix below).

     

       40
       40
       +
       

     

       41
       41
       +
             "Derivative Works" shall mean any work, whether in Source or Object

     

       42
       42
       +
             form, that is based on (or derived from) the Work and for which the

     

       43
       43
       +
             editorial revisions, annotations, elaborations, or other modifications

     

       44
       44
       +
             represent, as a whole, an original work of authorship. For the purposes

     

       45
       45
       +
             of this License, Derivative Works shall not include works that remain

     

       46
       46
       +
             separable from, or merely link (or bind by name) to the interfaces of,

     

       47
       47
       +
             the Work and Derivative Works thereof.

     

       48
       48
       +
       

     

       49
       49
       +
             "Contribution" shall mean any work of authorship, including

     

       50
       50
       +
             the original version of the Work and any modifications or additions

     

       51
       51
       +
             to that Work or Derivative Works thereof, that is intentionally

     

       52
       52
       +
             submitted to Licensor for inclusion in the Work by the copyright owner

     

       53
       53
       +
             or by an individual or Legal Entity authorized to submit on behalf of

     

       54
       54
       +
             the copyright owner. For the purposes of this definition, "submitted"

     

       55
       55
       +
             means any form of electronic, verbal, or written communication sent

     

       56
       56
       +
             to the Licensor or its representatives, including but not limited to

     

       57
       57
       +
             communication on electronic mailing lists, source code control systems,

     

       58
       58
       +
             and issue tracking systems that are managed by, or on behalf of, the

     

       59
       59
       +
             Licensor for the purpose of discussing and improving the Work, but

     

       60
       60
       +
             excluding communication that is conspicuously marked or otherwise

     

       61
       61
       +
             designated in writing by the copyright owner as "Not a Contribution."

     

       62
       62
       +
       

     

       63
       63
       +
             "Contributor" shall mean Licensor and any individual or Legal Entity

     

       64
       64
       +
             on behalf of whom a Contribution has been received by Licensor and

     

       65
       65
       +
             subsequently incorporated within the Work.

     

       66
       66
       +
       

     

       67
       67
       +
          2. Grant of Copyright License. Subject to the terms and conditions of

     

       68
       68
       +
             this License, each Contributor hereby grants to You a perpetual,

     

       69
       69
       +
             worldwide, non-exclusive, no-charge, royalty-free, irrevocable

     

       70
       70
       +
             copyright license to reproduce, prepare Derivative Works of,

     

       71
       71
       +
             publicly display, publicly perform, sublicense, and distribute the

     

       72
       72
       +
             Work and such Derivative Works in Source or Object form.

     

       73
       73
       +
       

     

       74
       74
       +
          3. Grant of Patent License. Subject to the terms and conditions of

     

       75
       75
       +
             this License, each Contributor hereby grants to You a perpetual,

     

       76
       76
       +
             worldwide, non-exclusive, no-charge, royalty-free, irrevocable

     

       77
       77
       +
             (except as stated in this section) patent license to make, have made,

     

       78
       78
       +
             use, offer to sell, sell, import, and otherwise transfer the Work,

     

       79
       79
       +
             where such license applies only to those patent claims licensable

     

       80
       80
       +
             by such Contributor that are necessarily infringed by their

     

       81
       81
       +
             Contribution(s) alone or by combination of their Contribution(s)

     

       82
       82
       +
             with the Work to which such Contribution(s) was submitted. If You

     

       83
       83
       +
             institute patent litigation against any entity (including a

     

       84
       84
       +
             cross-claim or counterclaim in a lawsuit) alleging that the Work

     

       85
       85
       +
             or a Contribution incorporated within the Work constitutes direct

     

       86
       86
       +
             or contributory patent infringement, then any patent licenses

     

       87
       87
       +
             granted to You under this License for that Work shall terminate

     

       88
       88
       +
             as of the date such litigation is filed.

     

       89
       89
       +
       

     

       90
       90
       +
          4. Redistribution. You may reproduce and distribute copies of the

     

       91
       91
       +
             Work or Derivative Works thereof in any medium, with or without

     

       92
       92
       +
             modifications, and in Source or Object form, provided that You

     

       93
       93
       +
             meet the following conditions:

     

       94
       94
       +
       

     

       95
       95
       +
             (a) You must give any other recipients of the Work or

     

       96
       96
       +
                 Derivative Works a copy of this License; and

     

       97
       97
       +
       

     

       98
       98
       +
             (b) You must cause any modified files to carry prominent notices

     

       99
       99
       +
                 stating that You changed the files; and

     

       100
       100
       +
       

     

       101
       101
       +
             (c) You must retain, in the Source form of any Derivative Works

     

       102
       102
       +
                 that You distribute, all copyright, patent, trademark, and

     

       103
       103
       +
                 attribution notices from the Source form of the Work,

     

       104
       104
       +
                 excluding those notices that do not pertain to any part of

     

       105
       105
       +
                 the Derivative Works; and

     

       106
       106
       +
       

     

       107
       107
       +
             (d) If the Work includes a "NOTICE" text file as part of its

     

       108
       108
       +
                 distribution, then any Derivative Works that You distribute must

     

       109
       109
       +
                 include a readable copy of the attribution notices contained

     

       110
       110
       +
                 within such NOTICE file, excluding those notices that do not

     

       111
       111
       +
                 pertain to any part of the Derivative Works, in at least one

     

       112
       112
       +
                 of the following places: within a NOTICE text file distributed

     

       113
       113
       +
                 as part of the Derivative Works; within the Source form or

     

       114
       114
       +
                 documentation, if provided along with the Derivative Works; or,

     

       115
       115
       +
                 within a display generated by the Derivative Works, if and

     

       116
       116
       +
                 wherever such third-party notices normally appear. The contents

     

       117
       117
       +
                 of the NOTICE file are for informational purposes only and

     

       118
       118
       +
                 do not modify the License. You may add Your own attribution

     

       119
       119
       +
                 notices within Derivative Works that You distribute, alongside

     

       120
       120
       +
                 or as an addendum to the NOTICE text from the Work, provided

     

       121
       121
       +
                 that such additional attribution notices cannot be construed

     

       122
       122
       +
                 as modifying the License.

     

       123
       123
       +
       

     

       124
       124
       +
             You may add Your own copyright statement to Your modifications and

     

       125
       125
       +
             may provide additional or different license terms and conditions

     

       126
       126
       +
             for use, reproduction, or distribution of Your modifications, or

     

       127
       127
       +
             for any such Derivative Works as a whole, provided Your use,

     

       128
       128
       +
             reproduction, and distribution of the Work otherwise complies with

     

       129
       129
       +
             the conditions stated in this License.

     

       130
       130
       +
       

     

       131
       131
       +
          5. Submission of Contributions. Unless You explicitly state otherwise,

     

       132
       132
       +
             any Contribution intentionally submitted for inclusion in the Work

     

       133
       133
       +
             by You to the Licensor shall be under the terms and conditions of

     

       134
       134
       +
             this License, without any additional terms or conditions.

     

       135
       135
       +
             Notwithstanding the above, nothing herein shall supersede or modify

     

       136
       136
       +
             the terms of any separate license agreement you may have executed

     

       137
       137
       +
             with Licensor regarding such Contributions.

     

       138
       138
       +
       

     

       139
       139
       +
          6. Trademarks. This License does not grant permission to use the trade

     

       140
       140
       +
             names, trademarks, service marks, or product names of the Licensor,

     

       141
       141
       +
             except as required for reasonable and customary use in describing the

     

       142
       142
       +
             origin of the Work and reproducing the content of the NOTICE file.

     

       143
       143
       +
       

     

       144
       144
       +
          7. Disclaimer of Warranty. Unless required by applicable law or

     

       145
       145
       +
             agreed to in writing, Licensor provides the Work (and each

     

       146
       146
       +
             Contributor provides its Contributions) on an "AS IS" BASIS,

     

       147
       147
       +
             WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or

     

       148
       148
       +
             implied, including, without limitation, any warranties or conditions

     

       149
       149
       +
             of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A

     

       150
       150
       +
             PARTICULAR PURPOSE. You are solely responsible for determining the

     

       151
       151
       +
             appropriateness of using or redistributing the Work and assume any

     

       152
       152
       +
             risks associated with Your exercise of permissions under this License.

     

       153
       153
       +
       

     

       154
       154
       +
          8. Limitation of Liability. In no event and under no legal theory,

     

       155
       155
       +
             whether in tort (including negligence), contract, or otherwise,

     

       156
       156
       +
             unless required by applicable law (such as deliberate and grossly

     

       157
       157
       +
             negligent acts) or agreed to in writing, shall any Contributor be

     

       158
       158
       +
             liable to You for damages, including any direct, indirect, special,

     

       159
       159
       +
             incidental, or consequential damages of any character arising as a

     

       160
       160
       +
             result of this License or out of the use or inability to use the

     

       161
       161
       +
             Work (including but not limited to damages for loss of goodwill,

     

       162
       162
       +
             work stoppage, computer failure or malfunction, or any and all

     

       163
       163
       +
             other commercial damages or losses), even if such Contributor

     

       164
       164
       +
             has been advised of the possibility of such damages.

     

       165
       165
       +
       

     

       166
       166
       +
          9. Accepting Warranty or Additional Liability. While redistributing

     

       167
       167
       +
             the Work or Derivative Works thereof, You may choose to offer,

     

       168
       168
       +
             and charge a fee for, acceptance of support, warranty, indemnity,

     

       169
       169
       +
             or other liability obligations and/or rights consistent with this

     

       170
       170
       +
             License. However, in accepting such obligations, You may act only

     

       171
       171
       +
             on Your own behalf and on Your sole responsibility, not on behalf

     

       172
       172
       +
             of any other Contributor, and only if You agree to indemnify,

     

       173
       173
       +
             defend, and hold each Contributor harmless for any liability

     

       174
       174
       +
             incurred by, or claims asserted against, such Contributor by reason

     

       175
       175
       +
             of your accepting any such warranty or additional liability.

     

       176
       176
       +
       

     

       177
       177
       +
          END OF TERMS AND CONDITIONS

     

       178
       178
       +
       

     

       179
       179
       +
          APPENDIX: How to apply the Apache License to your work.

     

       180
       180
       +
       

     

       181
       181
       +
             To apply the Apache License to your work, attach the following

     

       182
       182
       +
             boilerplate notice, with the fields enclosed by brackets "[]"

     

       183
       183
       +
             replaced with your own identifying information. (Don't include

     

       184
       184
       +
             the brackets!)  The text should be enclosed in the appropriate

     

       185
       185
       +
             comment syntax for the file format. We also recommend that a

     

       186
       186
       +
             file or class name and description of purpose be included on the

     

       187
       187
       +
             same "printed page" as the copyright notice for easier

     

       188
       188
       +
             identification within third-party archives.

     

       189
       189
       +
       

     

       190
       190
       +
          Copyright [yyyy] [name of copyright owner]

     

       191
       191
       +
       

     

       192
       192
       +
          Licensed under the Apache License, Version 2.0 (the "License");

     

       193
       193
       +
          you may not use this file except in compliance with the License.

     

       194
       194
       +
          You may obtain a copy of the License at

     

       195
       195
       +
       

     

       196
       196
       +
              http://www.apache.org/licenses/LICENSE-2.0

     

       197
       197
       +
       

     

       198
       198
       +
          Unless required by applicable law or agreed to in writing, software

     

       199
       199
       +
          distributed under the License is distributed on an "AS IS" BASIS,

     

       200
       200
       +
          WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

     

       201
       201
       +
          See the License for the specific language governing permissions and

     

       202
       202
       +
          limitations under the License.

+19

LICENSE-MIT

···

       1
       1
       +
       MIT License

     

       2
       2
       +
       

     

       3
       3
       +
       Permission is hereby granted, free of charge, to any person obtaining a copy

     

       4
       4
       +
       of this software and associated documentation files (the "Software"), to deal

     

       5
       5
       +
       in the Software without restriction, including without limitation the rights

     

       6
       6
       +
       to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

     

       7
       7
       +
       copies of the Software, and to permit persons to whom the Software is

     

       8
       8
       +
       furnished to do so, subject to the following conditions:

     

       9
       9
       +
       

     

       10
       10
       +
       The above copyright notice and this permission notice shall be included in all

     

       11
       11
       +
       copies or substantial portions of the Software.

     

       12
       12
       +
       

     

       13
       13
       +
       THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

     

       14
       14
       +
       IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

     

       15
       15
       +
       FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

     

       16
       16
       +
       AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

     

       17
       17
       +
       LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

     

       18
       18
       +
       OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

     

       19
       19
       +
       SOFTWARE.

+15 -6

README.md

···

       1
       1
       -
       # DID Placeholder Method (did:plc)

     

       1
       1
       +
       # DID PLC Method (did:plc)

     

       2
       2
        
       

     

       3
       3
       -
       DID Placeholder is a self-authenticating [DID](https://www.w3.org/TR/did-core/) which is strongly-consistent, recoverable, and allows for key rotation.

     

       3
       3
       +
       DID PLC is a self-authenticating [DID](https://www.w3.org/TR/did-core/) which is strongly-consistent, recoverable, and allows for key rotation.

     

       4
       4
        
       

     

       5
       5
        
       An example DID is: `did:plc:yk4dd2qkboz2yv6tpubpc6co`

     

       6
       6
        
       

     
···

       8
       8
        
       

     

       9
       9
        
       ## Motivation

     

       10
       10
        
       

     

       11
       11
       -
       [Bluesky](https://blueskyweb.xyz/) developed DID Placeholder when designing the [AT Protocol](https://atproto.com) ("atproto") because we were not satisfied with any of the existing DID methods.

     

       11
       11
       +
       [Bluesky](https://blueskyweb.xyz/) developed DID PLC when designing the [AT Protocol](https://atproto.com) ("atproto") because we were not satisfied with any of the existing DID methods.

     

       12
       12
        
       We wanted a strongly consistent, highly available, recoverable, and cryptographically secure method with fast and cheap propagation of updates.

     

       13
       13
        
       

     

       14
       14
       -
       We titled the method "Placeholder", because we _don't_ want it to stick around forever in its current form. We are actively hoping to replace it with or evolve it into something less centralized - likely a permissioned DID consortium. That being said, we do intend to support `did:plc` in the current form until after any successor is deployed, with a reasonable grace period. We would also provide a migration route to allow continued use of existing `did:plc` identifiers.

     

       14
       14
       +
       We originally titled the method "Placeholder", because we didn't want it to stick around forever in its current form. We are actively hoping to replace it with or evolve it into something less centralized - likely a permissioned DID consortium. That being said, we do intend to support `did:plc` in the current form until after any successor is deployed, with a reasonable grace period. We would also provide a migration route to allow continued use of existing `did:plc` identifiers.

     

       15
       15
        
       

     

       16
       16
        
       ## How it works

     

       17
       17
        
       

     
···

       99
       99
        
       

     

       100
       100
        
       ### Identifier Syntax

     

       101
       101
        
       

     

       102
       102
       -
       The DID Placeholder method name is `plc`. The identifier part is 24 characters

     

       102
       102
       +
       The DID PLC method name is `plc`. The identifier part is 24 characters

     

       103
       103
        
       long, including only characters from the `base32` encoding set. An example is

     

       104
       104
        
       `did:plc:yk4dd2qkboz2yv6tpubpc6co`. This means:

     

       105
       105
        
       

     
···

       387
       387
        
       

     

       388
       388
        
       We welcome proposals for small additions to make `did:plc` more generic and reusable for applications other than atproto. But no promises: atproto will remain the focus for the near future.

     

       389
       389
        
       

     

       390
       390
       -
       Moving governance of the `did:plc` method, and operation of registry servers, out of the sole control of Bluesky PBLLC is something we are enthusiastic about. Audit log snapshots, mirroring, and automated third-party auditing have all been considered as mechanisms to mitigate the centralized nature of the PLC server.

     

       390
       390
       +
       Moving governance of the `did:plc` method, and operation of registry servers, out of the sole control of Bluesky PBC is something we are enthusiastic about. Audit log snapshots, mirroring, and automated third-party auditing have all been considered as mechanisms to mitigate the centralized nature of the PLC server.

     

       391
       391
        
       

     

       392
       392
        
       The size of the `verificationMethods`, `alsoKnownAs`, and `service` mappings/arrays may be specifically constrained. And the maximum DAG-CBOR size may be constrained.

     

       393
       393
        
       

     
···

       396
       396
        
       A "DID PLC history explorer" web interface would make the public nature of the DID audit log more publicly understandable.

     

       397
       397
        
       

     

       398
       398
        
       It is concievable that longer DID PLCs, with more of the SHA-256 characters, will be supported in the future. It is also concievable that a different hash algorithm would be allowed. Any such changes would allow existing DIDs in their existing syntax to continue being used.

     

       399
       399
       +
       

     

       400
       400
       +
       ## License

     

       401
       401
       +
       

     

       402
       402
       +
       This project is dual-licensed under MIT and Apache 2.0 terms:

     

       403
       403
       +
       

     

       404
       404
       +
       - Apache License, Version 2.0, ([LICENSE-APACHE](https://github.com/ipfs/kubo/blob/master/LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)

     

       405
       405
       +
       - MIT license ([LICENSE-MIT](https://github.com/ipfs/kubo/blob/master/LICENSE-MIT) or http://opensource.org/licenses/MIT)

     

       406
       406
       +
       

     

       407
       407
       +
       Downstream projects and users may chose either license, or both, at their discretion. The motivation for this dual-licensing is the additional software patent assurance provided by Apache 2.0.

+1 -1

package.json

···

       2
       2
        
         "name": "did-method-plc",

     

       3
       3
        
         "version": "0.0.1",

     

       4
       4
        
         "repository": "git@github.com:bluesky-social/did-method-plc.git",

     

       5
       5
       -
         "author": "Bluesky PBLLC <hello@blueskyweb.xyz>",

     

       5
       5
       +
         "author": "Bluesky PBC <hello@blueskyweb.xyz>",

     

       6
       6
        
         "license": "MIT",

     

       7
       7
        
         "private": true,

     

       8
       8
        
         "engines": {

+50 -1

packages/lib/README.md

···

       1
       1
       -
       # DID Placeholder Library

     

       1
       1
       +
       

     

       2
       2
       +
       @did-plc/lib - DID PLC Typescript Client Library

     

       3
       3
       +
       ================================================

     

       4
       4
       +
       

     

       5
       5
       +
       [![NPM](https://img.shields.io/npm/v/@did-plc/lib)](https://www.npmjs.com/package/@did-plc/lib)

     

       6
       6
       +
       [![Github CI Status](https://github.com/bluesky-social/did-method-plc/actions/workflows/repo.yaml/badge.svg)](https://github.com/bluesky-social/did-method-plc/actions/workflows/repo.yaml)

     

       7
       7
       +
       

     

       8
       8
       +
       This library provides both a simple client for the PLC directory, and an implementation of the PLC method itself (using a cryptographically signed operation log).

     

       9
       9
       +
       

     

       10
       10
       +
       ## Client Usage

     

       11
       11
       +
       

     

       12
       12
       +
       Fetching account data from directory:

     

       13
       13
       +
       

     

       14
       14
       +
       ```typescript

     

       15
       15
       +
       import * as plc from '@did-plc/lib'

     

       16
       16
       +
       

     

       17
       17
       +
       client = new plc.Client('https://plc.directory')

     

       18
       18
       +
       

     

       19
       19
       +
       let exampleDid = 'did:plc:yk4dd2qkboz2yv6tpubpc6co'

     

       20
       20
       +
       

     

       21
       21
       +
       // current account data, in terse object format

     

       22
       22
       +
       const data = await client.getDocumentData(exampleDid)

     

       23
       23
       +
       

     

       24
       24
       +
       // or, the full DID Document

     

       25
       25
       +
       const didDoc = await client.getDocument(exampleDid)

     

       26
       26
       +
       ```

     

       27
       27
       +
       

     

       28
       28
       +
       Registering a new DID PLC:

     

       29
       29
       +
       

     

       30
       30
       +
       ```typescript

     

       31
       31
       +
       import { Secp256k1Keypair } from '@atproto/crypto'

     

       32
       32
       +
       import * as plc from '@did-plc/lib'

     

       33
       33
       +
       

     

       34
       34
       +
       // please test against a sandbox or local development server

     

       35
       35
       +
       client = new plc.Client('http://localhost:2582')

     

       36
       36
       +
       

     

       37
       37
       +
       let signingKey = await Secp256k1Keypair.create()

     

       38
       38
       +
       let rotationKey = await Secp256k1Keypair.create()

     

       39
       39
       +
       

     

       40
       40
       +
       did = await client.createDid({

     

       41
       41
       +
           signingKey: signingKey.did(),

     

       42
       42
       +
           handle: 'handle.example.com',

     

       43
       43
       +
           pds: 'https://pds.example.com',

     

       44
       44
       +
           rotationKeys: [rotationKey.did()],

     

       45
       45
       +
           signer: rotationKey,

     

       46
       46
       +
       })

     

       47
       47
       +
       ```

     

       2
       48
        
       

     

       49
       49
       +
       ## License

     

       50
       50
       +
       

     

       51
       51
       +
       MIT / Apache 2.0 dual-licensed.

+16 -4

packages/lib/package.json

···

       1
       1
        
       {

     

       2
       2
        
         "name": "@did-plc/lib",

     

       3
       3
        
         "version": "0.0.4",

     

       4
       4
       -
         "main": "src/index.ts",

     

       5
       4
        
         "license": "MIT",

     

       5
       5
       +
         "description": "DID PLC Typescript Client Library",

     

       6
       6
       +
         "keywords": [

     

       7
       7
       +
           "did-plc",

     

       8
       8
       +
           "did",

     

       9
       9
       +
           "atproto"

     

       10
       10
       +
         ],

     

       11
       11
       +
         "homepage": "https://web.plc.directory",

     

       12
       12
       +
         "repository": {

     

       13
       13
       +
           "type": "git",

     

       14
       14
       +
           "url": "https://github.com/bluesky-social/did-method-plc",

     

       15
       15
       +
           "directory": "packages/lib"

     

       16
       16
       +
         },

     

       17
       17
       +
         "main": "dist/index.js",

     

       6
       18
        
         "scripts": {

     

       7
       19
        
           "test": "jest",

     

       8
       20
        
           "prettier": "prettier --check src/",

     
···

       19
       31
        
           "postpublish": "npm run update-main-to-src"

     

       20
       32
        
         },

     

       21
       33
        
         "dependencies": {

     

       22
       22
       -
           "@atproto/common": "0.1.1",

     

       23
       23
       -
           "@atproto/crypto": "0.1.0",

     

       34
       34
       +
           "@atproto/common": "0.3.0",

     

       35
       35
       +
           "@atproto/crypto": "0.2.2",

     

       24
       36
        
           "@ipld/dag-cbor": "^7.0.3",

     

       25
       37
        
           "axios": "^1.3.4",

     

       26
       38
        
           "multiformats": "^9.6.4",

     

       27
       39
        
           "uint8arrays": "3.0.0",

     

       28
       28
       -
           "zod": "^3.14.2"

     

       40
       40
       +
           "zod": "^3.21.4"

     

       29
       41
        
         },

     

       30
       42
        
         "devDependencies": {

     

       31
       43
        
           "eslint-plugin-prettier": "^4.2.1"

-8

packages/lib/src/data.ts

···

       3
       3
        
       import * as t from './types'

     

       4
       4
        
       import {

     

       5
       5
        
         assureValidCreationOp,

     

       6
       6
       -
         assureValidOp,

     

       7
       6
        
         assureValidSig,

     

       8
       7
        
         normalizeOp,

     

       9
       8
        
       } from './operations'

     
···

       18
       17
        
         ops: t.IndexedOperation[],

     

       19
       18
        
         proposed: t.CompatibleOpOrTombstone,

     

       20
       19
        
       ): Promise<{ nullified: CID[]; prev: CID | null }> => {

     

       21
       21
       -
         if (check.is(proposed, t.def.createOpV1)) {

     

       22
       22
       -
           const normalized = normalizeOp(proposed)

     

       23
       23
       -
           await assureValidOp(normalized)

     

       24
       24
       -
         } else {

     

       25
       25
       -
           await assureValidOp(proposed)

     

       26
       26
       -
         }

     

       27
       27
       -
       

     

       28
       20
        
         // special case if account creation

     

       29
       21
        
         if (ops.length === 0) {

     

       30
       22
        
           await assureValidCreationOp(did, proposed)

+2 -2

packages/lib/src/document.ts

···

       2
       2
        
       import * as crypto from '@atproto/crypto'

     

       3
       3
        
       import * as t from './types'

     

       4
       4
        
       import { UnsupportedKeyError } from './error'

     

       5
       5
       -
       import { ParsedDidKey } from '@atproto/crypto'

     

       5
       5
       +
       import { ParsedMultikey } from '@atproto/crypto'

     

       6
       6
        
       

     

       7
       7
        
       export const formatDidDoc = (data: t.DocumentData): t.DidDocument => {

     

       8
       8
        
         const context = ['https://www.w3.org/ns/did/v1']

     
···

       59
       59
        
       }

     

       60
       60
        
       

     

       61
       61
        
       const formatKeyAndContext = (key: string): KeyAndContext => {

     

       62
       62
       -
         let keyInfo: ParsedDidKey

     

       62
       62
       +
         let keyInfo: ParsedMultikey

     

       63
       63
        
         try {

     

       64
       64
        
           keyInfo = crypto.parseDidKey(key)

     

       65
       65
        
         } catch (err) {

+1 -25

packages/lib/src/operations.ts

···

       1
       1
        
       import * as cbor from '@ipld/dag-cbor'

     

       2
       2
        
       import { CID } from 'multiformats/cid'

     

       3
       3
        
       import * as uint8arrays from 'uint8arrays'

     

       4
       4
       -
       import { Keypair, parseDidKey, sha256, verifySignature } from '@atproto/crypto'

     

       4
       4
       +
       import { Keypair, sha256, verifySignature } from '@atproto/crypto'

     

       5
       5
        
       import { check, cidForCbor } from '@atproto/common'

     

       6
       6
        
       import * as t from './types'

     

       7
       7
        
       import {

     
···

       9
       9
        
         ImproperOperationError,

     

       10
       10
        
         InvalidSignatureError,

     

       11
       11
        
         MisorderedOperationError,

     

       12
       12
       -
         UnsupportedKeyError,

     

       13
       12
        
       } from './error'

     

       14
       13
        
       

     

       15
       14
        
       export const didForCreateOp = async (op: t.CompatibleOp) => {

     
···

       240
       239
        
       // Verifying operations/signatures

     

       241
       240
        
       // ---------------------------

     

       242
       241
        
       

     

       243
       243
       -
       export const assureValidOp = async (op: t.OpOrTombstone) => {

     

       244
       244
       -
         if (check.is(op, t.def.tombstone)) {

     

       245
       245
       -
           return true

     

       246
       246
       -
         }

     

       247
       247
       -
         // ensure we support the op's keys

     

       248
       248
       -
         const keys = [...Object.values(op.verificationMethods), ...op.rotationKeys]

     

       249
       249
       -
         await Promise.all(

     

       250
       250
       -
           keys.map(async (k) => {

     

       251
       251
       -
             try {

     

       252
       252
       -
               parseDidKey(k)

     

       253
       253
       -
             } catch (err) {

     

       254
       254
       -
               throw new UnsupportedKeyError(k, err)

     

       255
       255
       -
             }

     

       256
       256
       -
           }),

     

       257
       257
       -
         )

     

       258
       258
       -
         if (op.rotationKeys.length > 5) {

     

       259
       259
       -
           throw new ImproperOperationError('too many rotation keys', op)

     

       260
       260
       -
         } else if (op.rotationKeys.length < 1) {

     

       261
       261
       -
           throw new ImproperOperationError('need at least one rotation key', op)

     

       262
       262
       -
         }

     

       263
       263
       -
       }

     

       264
       264
       -
       

     

       265
       242
        
       export const assureValidCreationOp = async (

     

       266
       243
        
         did: string,

     

       267
       244
        
         op: t.CompatibleOpOrTombstone,

     
···

       270
       247
        
           throw new MisorderedOperationError()

     

       271
       248
        
         }

     

       272
       249
        
         const normalized = normalizeOp(op)

     

       273
       273
       -
         await assureValidOp(normalized)

     

       274
       250
        
         await assureValidSig(normalized.rotationKeys, op)

     

       275
       251
        
         const expectedDid = await didForCreateOp(op)

     

       276
       252
        
         if (expectedDid !== did) {

+18 -14

packages/lib/src/types.ts

···

       34
       34
        
       const createOpV1 = unsignedCreateOpV1.extend({ sig: z.string() })

     

       35
       35
        
       export type CreateOpV1 = z.infer<typeof createOpV1>

     

       36
       36
        
       

     

       37
       37
       -
       const unsignedOperation = z.object({

     

       38
       38
       -
         type: z.literal('plc_operation'),

     

       39
       39
       -
         rotationKeys: z.array(z.string()),

     

       40
       40
       -
         verificationMethods: z.record(z.string()),

     

       41
       41
       -
         alsoKnownAs: z.array(z.string()),

     

       42
       42
       -
         services: z.record(service),

     

       43
       43
       -
         prev: z.string().nullable(),

     

       44
       44
       -
       })

     

       37
       37
       +
       const unsignedOperation = z

     

       38
       38
       +
         .object({

     

       39
       39
       +
           type: z.literal('plc_operation'),

     

       40
       40
       +
           rotationKeys: z.array(z.string()),

     

       41
       41
       +
           verificationMethods: z.record(z.string()),

     

       42
       42
       +
           alsoKnownAs: z.array(z.string()),

     

       43
       43
       +
           services: z.record(service),

     

       44
       44
       +
           prev: z.string().nullable(),

     

       45
       45
       +
         })

     

       46
       46
       +
         .strict()

     

       45
       47
        
       export type UnsignedOperation = z.infer<typeof unsignedOperation>

     

       46
       46
       -
       const operation = unsignedOperation.extend({ sig: z.string() })

     

       48
       48
       +
       const operation = unsignedOperation.extend({ sig: z.string() }).strict()

     

       47
       49
        
       export type Operation = z.infer<typeof operation>

     

       48
       50
        
       

     

       49
       49
       -
       const unsignedTombstone = z.object({

     

       50
       50
       -
         type: z.literal('plc_tombstone'),

     

       51
       51
       -
         prev: z.string(),

     

       52
       52
       -
       })

     

       51
       51
       +
       const unsignedTombstone = z

     

       52
       52
       +
         .object({

     

       53
       53
       +
           type: z.literal('plc_tombstone'),

     

       54
       54
       +
           prev: z.string(),

     

       55
       55
       +
         })

     

       56
       56
       +
         .strict()

     

       53
       57
        
       export type UnsignedTombstone = z.infer<typeof unsignedTombstone>

     

       54
       54
       -
       const tombstone = unsignedTombstone.extend({ sig: z.string() })

     

       58
       58
       +
       const tombstone = unsignedTombstone.extend({ sig: z.string() }).strict()

     

       55
       59
        
       export type Tombstone = z.infer<typeof tombstone>

     

       56
       60
        
       

     

       57
       61
        
       const opOrTombstone = z.union([operation, tombstone])

+3 -3

packages/lib/tests/data.test.ts

···

       1
       1
        
       import { check, cidForCbor } from '@atproto/common'

     

       2
       2
       -
       import { EcdsaKeypair, Secp256k1Keypair } from '@atproto/crypto'

     

       2
       2
       +
       import { P256Keypair, Secp256k1Keypair } from '@atproto/crypto'

     

       3
       3
        
       import {

     

       4
       4
        
         GenesisHashError,

     

       5
       5
        
         ImproperOperationError,

     
···

       15
       15
        
       

     

       16
       16
        
         let signingKey: Secp256k1Keypair

     

       17
       17
        
         let rotationKey1: Secp256k1Keypair

     

       18
       18
       -
         let rotationKey2: EcdsaKeypair

     

       18
       18
       +
         let rotationKey2: P256Keypair

     

       19
       19
        
         let did: string

     

       20
       20
        
         let handle = 'at://alice.example.com'

     

       21
       21
        
         let atpPds = 'https://example.com'

     
···

       25
       25
        
         beforeAll(async () => {

     

       26
       26
        
           signingKey = await Secp256k1Keypair.create()

     

       27
       27
        
           rotationKey1 = await Secp256k1Keypair.create()

     

       28
       28
       -
           rotationKey2 = await EcdsaKeypair.create()

     

       28
       28
       +
           rotationKey2 = await P256Keypair.create()

     

       29
       29
        
         })

     

       30
       30
        
       

     

       31
       31
        
         const lastOp = () => {

+3 -3

packages/lib/tests/document.test.ts

···

       1
       1
        
       import * as uint8arrays from 'uint8arrays'

     

       2
       2
       -
       import { EcdsaKeypair, parseDidKey, Secp256k1Keypair } from '@atproto/crypto'

     

       2
       2
       +
       import { P256Keypair, parseDidKey, Secp256k1Keypair } from '@atproto/crypto'

     

       3
       3
        
       import * as document from '../src/document'

     

       4
       4
        
       import * as t from '../src/types'

     

       5
       5
        
       

     

       6
       6
        
       describe('document', () => {

     

       7
       7
        
         it('formats a valid DID document', async () => {

     

       8
       8
        
           const atprotoKey = await Secp256k1Keypair.create()

     

       9
       9
       -
           const otherKey = await EcdsaKeypair.create()

     

       9
       9
       +
           const otherKey = await P256Keypair.create()

     

       10
       10
        
           const rotate1 = await Secp256k1Keypair.create()

     

       11
       11
       -
           const rotate2 = await EcdsaKeypair.create()

     

       11
       11
       +
           const rotate2 = await P256Keypair.create()

     

       12
       12
        
           const alsoKnownAs = ['at://alice.test', 'https://bob.test']

     

       13
       13
        
           const atpPds = 'https://example.com'

     

       14
       14
        
           const otherService = 'https://other.com'

+5 -5

packages/lib/tests/recovery.test.ts

···

       1
       1
        
       import { cidForCbor, DAY, HOUR } from '@atproto/common'

     

       2
       2
       -
       import { EcdsaKeypair, Keypair, Secp256k1Keypair } from '@atproto/crypto'

     

       2
       2
       +
       import { P256Keypair, Keypair, Secp256k1Keypair } from '@atproto/crypto'

     

       3
       3
        
       import { CID } from 'multiformats/cid'

     

       4
       4
        
       import { InvalidSignatureError, LateRecoveryError } from '../src'

     

       5
       5
        
       import * as data from '../src/data'

     
···

       9
       9
        
       describe('plc recovery', () => {

     

       10
       10
        
         let signingKey: Secp256k1Keypair

     

       11
       11
        
         let rotationKey1: Secp256k1Keypair

     

       12
       12
       -
         let rotationKey2: EcdsaKeypair

     

       13
       13
       -
         let rotationKey3: EcdsaKeypair

     

       12
       12
       +
         let rotationKey2: P256Keypair

     

       13
       13
       +
         let rotationKey3: P256Keypair

     

       14
       14
        
         let did: string

     

       15
       15
        
         const handle = 'alice.example.com'

     

       16
       16
        
         const atpPds = 'https://example.com'

     
···

       22
       22
        
         beforeAll(async () => {

     

       23
       23
        
           signingKey = await Secp256k1Keypair.create()

     

       24
       24
        
           rotationKey1 = await Secp256k1Keypair.create()

     

       25
       25
       -
           rotationKey2 = await EcdsaKeypair.create()

     

       26
       26
       -
           rotationKey3 = await EcdsaKeypair.create()

     

       25
       25
       +
           rotationKey2 = await P256Keypair.create()

     

       26
       26
       +
           rotationKey3 = await P256Keypair.create()

     

       27
       27
        
         })

     

       28
       28
        
       

     

       29
       29
        
         const formatIndexed = async (

+1 -1

packages/server/Dockerfile

···

       35
       35
        
       CMD ["node", "--enable-source-maps", "index.js"]

     

       36
       36
        
       

     

       37
       37
        
       LABEL org.opencontainers.image.source=https://github.com/bluesky-social/did-method-plc

     

       38
       38
       -
       LABEL org.opencontainers.image.description="DID Placeholder server"

     

       38
       38
       +
       LABEL org.opencontainers.image.description="DID PLC server"

     

       39
       39
        
       LABEL org.opencontainers.image.licenses=MIT

+11 -1

packages/server/README.md

···

       1
       1
       -
       # DID Placeholder Server
     

       1
       1
       +
       

     

       2
       2
       +
       @did-plc/server - DID PLC Directory Service

     

       3
       3
       +
       ===========================================

     

       4
       4
       +
       

     

       5
       5
       +
       Reference implementation of the PLC DID method, in Typescript.

     

       6
       6
       +
       

     

       7
       7
       +
       This is the software that runs the <https://plc.directory> service.

     

       8
       8
       +
       

     

       9
       9
       +
       ## License

     

       10
       10
       +
       

     

       11
       11
       +
       MIT / Apache 2.0 dual-licensed.

+15 -3

packages/server/package.json

···

       1
       1
        
       {

     

       2
       2
        
         "name": "@did-plc/server",

     

       3
       3
        
         "version": "0.0.1",

     

       4
       4
       -
         "main": "dist/index.js",

     

       5
       4
        
         "license": "MIT",

     

       5
       5
       +
         "description": "DID PLC Directory Service",

     

       6
       6
       +
         "keywords": [

     

       7
       7
       +
           "did-plc",

     

       8
       8
       +
           "did",

     

       9
       9
       +
           "atproto"

     

       10
       10
       +
         ],

     

       11
       11
       +
         "homepage": "https://web.plc.directory",

     

       12
       12
       +
         "repository": {

     

       13
       13
       +
           "type": "git",

     

       14
       14
       +
           "url": "https://github.com/bluesky-social/did-method-plc",

     

       15
       15
       +
           "directory": "packages/server"

     

       16
       16
       +
         },

     

       17
       17
       +
         "main": "dist/index.js",

     

       6
       18
        
         "scripts": {

     

       7
       19
        
           "start": "node dist/bin.js",

     

       8
       20
        
           "test": "./pg/with-test-db.sh jest",

     
···

       23
       35
        
           "postpublish": "npm run update-main-to-src"

     

       24
       36
        
         },

     

       25
       37
        
         "dependencies": {

     

       26
       26
       -
           "@atproto/common": "0.1.1",

     

       27
       27
       -
           "@atproto/crypto": "0.1.0",

     

       38
       38
       +
           "@atproto/common": "0.3.0",

     

       39
       39
       +
           "@atproto/crypto": "0.2.2",

     

       28
       40
        
           "@did-plc/lib": "*",

     

       29
       41
        
           "axios": "^1.3.4",

     

       30
       42
        
           "cors": "^2.8.5",

+2 -2

packages/server/service/index.js

···

       30
       30
        
         })

     

       31
       31
        
       }

     

       32
       32
        
       

     

       33
       33
       -
       const pgUrl = ({ username, password, host, port }) => {

     

       33
       33
       +
       const pgUrl = ({ username = "postgres", password = "postgres", host = "localhost", port = "5432", database = "postgres", sslmode }) => {

     

       34
       34
        
         const enc = encodeURIComponent

     

       35
       35
       -
         return `postgresql://${username}:${enc(password)}@${host}:${port}/postgres`

     

       35
       35
       +
         return `postgresql://${username}:${enc(password)}@${host}:${port}/${database}${sslmode ? `?sslmode=${enc(sslmode)}` : ''}`

     

       36
       36
        
       }

     

       37
       37
        
       

     

       38
       38
        
       main()

+147

packages/server/src/constraints.ts

···

       1
       1
       +
       import { DAY, HOUR, cborEncode, check } from '@atproto/common'

     

       2
       2
       +
       import * as plc from '@did-plc/lib'

     

       3
       3
       +
       import { ServerError } from './error'

     

       4
       4
       +
       import { parseDidKey } from '@atproto/crypto'

     

       5
       5
       +
       

     

       6
       6
       +
       const MAX_OP_BYTES = 4000

     

       7
       7
       +
       const MAX_AKA_ENTRIES = 10

     

       8
       8
       +
       const MAX_AKA_LENGTH = 256

     

       9
       9
       +
       const MAX_ROTATION_ENTRIES = 10

     

       10
       10
       +
       const MAX_SERVICE_ENTRIES = 10

     

       11
       11
       +
       const MAX_SERVICE_TYPE_LENGTH = 256

     

       12
       12
       +
       const MAX_SERVICE_ENDPOINT_LENGTH = 512

     

       13
       13
       +
       const MAX_ID_LENGTH = 32

     

       14
       14
       +
       

     

       15
       15
       +
       export function assertValidIncomingOp(

     

       16
       16
       +
         op: unknown,

     

       17
       17
       +
       ): asserts op is plc.OpOrTombstone {

     

       18
       18
       +
         const byteLength = cborEncode(op).byteLength

     

       19
       19
       +
         if (byteLength > MAX_OP_BYTES) {

     

       20
       20
       +
           throw new ServerError(

     

       21
       21
       +
             400,

     

       22
       22
       +
             `Operation too large (${MAX_OP_BYTES} bytes maximum in cbor encoding)`,

     

       23
       23
       +
           )

     

       24
       24
       +
         }

     

       25
       25
       +
         if (!check.is(op, plc.def.opOrTombstone)) {

     

       26
       26
       +
           throw new ServerError(400, `Not a valid operation: ${JSON.stringify(op)}`)

     

       27
       27
       +
         }

     

       28
       28
       +
         if (op.type === 'plc_tombstone') {

     

       29
       29
       +
           return

     

       30
       30
       +
         }

     

       31
       31
       +
         if (op.alsoKnownAs.length > MAX_AKA_ENTRIES) {

     

       32
       32
       +
           throw new ServerError(

     

       33
       33
       +
             400,

     

       34
       34
       +
             `To many alsoKnownAs entries (max ${MAX_AKA_ENTRIES})`,

     

       35
       35
       +
           )

     

       36
       36
       +
         }

     

       37
       37
       +
         const akaDupe: Record<string, boolean> = {}

     

       38
       38
       +
         for (const aka of op.alsoKnownAs) {

     

       39
       39
       +
           if (aka.length > MAX_AKA_LENGTH) {

     

       40
       40
       +
             throw new ServerError(

     

       41
       41
       +
               400,

     

       42
       42
       +
               `alsoKnownAs entry too long (max ${MAX_AKA_LENGTH}): ${aka}`,

     

       43
       43
       +
             )

     

       44
       44
       +
           }

     

       45
       45
       +
           if (akaDupe[aka]) {

     

       46
       46
       +
             throw new ServerError(400, `duplicate alsoKnownAs entry: ${aka}`)

     

       47
       47
       +
           } else {

     

       48
       48
       +
             akaDupe[aka] = true

     

       49
       49
       +
           }

     

       50
       50
       +
         }

     

       51
       51
       +
         if (op.rotationKeys.length > MAX_ROTATION_ENTRIES) {

     

       52
       52
       +
           throw new ServerError(

     

       53
       53
       +
             400,

     

       54
       54
       +
             `Too many rotationKey entries (max ${MAX_ROTATION_ENTRIES})`,

     

       55
       55
       +
           )

     

       56
       56
       +
         }

     

       57
       57
       +
         for (const key of op.rotationKeys) {

     

       58
       58
       +
           try {

     

       59
       59
       +
             parseDidKey(key)

     

       60
       60
       +
           } catch (err) {

     

       61
       61
       +
             throw new ServerError(400, `Invalid rotationKey: ${key}`)

     

       62
       62
       +
           }

     

       63
       63
       +
         }

     

       64
       64
       +
         const serviceEntries = Object.entries(op.services)

     

       65
       65
       +
         if (serviceEntries.length > MAX_SERVICE_ENTRIES) {

     

       66
       66
       +
           throw new ServerError(

     

       67
       67
       +
             400,

     

       68
       68
       +
             `To many service entries (max ${MAX_SERVICE_ENTRIES})`,

     

       69
       69
       +
           )

     

       70
       70
       +
         }

     

       71
       71
       +
         for (const [id, service] of serviceEntries) {

     

       72
       72
       +
           if (id.length > MAX_ID_LENGTH) {

     

       73
       73
       +
             throw new ServerError(

     

       74
       74
       +
               400,

     

       75
       75
       +
               `Service id too long (max ${MAX_ID_LENGTH}): ${id}`,

     

       76
       76
       +
             )

     

       77
       77
       +
           }

     

       78
       78
       +
           if (service.type.length > MAX_SERVICE_TYPE_LENGTH) {

     

       79
       79
       +
             throw new ServerError(

     

       80
       80
       +
               400,

     

       81
       81
       +
               `Service type too long (max ${MAX_SERVICE_TYPE_LENGTH})`,

     

       82
       82
       +
             )

     

       83
       83
       +
           }

     

       84
       84
       +
           if (service.endpoint.length > MAX_SERVICE_ENDPOINT_LENGTH) {

     

       85
       85
       +
             throw new ServerError(

     

       86
       86
       +
               400,

     

       87
       87
       +
               `Service endpoint too long (max ${MAX_SERVICE_ENDPOINT_LENGTH})`,

     

       88
       88
       +
             )

     

       89
       89
       +
           }

     

       90
       90
       +
         }

     

       91
       91
       +
         const verifyMethods = Object.entries(op.verificationMethods)

     

       92
       92
       +
         for (const [id, key] of verifyMethods) {

     

       93
       93
       +
           if (id.length > MAX_ID_LENGTH) {

     

       94
       94
       +
             throw new ServerError(

     

       95
       95
       +
               400,

     

       96
       96
       +
               `Verification Method id too long (max ${MAX_ID_LENGTH}): ${id}`,

     

       97
       97
       +
             )

     

       98
       98
       +
           }

     

       99
       99
       +
           try {

     

       100
       100
       +
             parseDidKey(key)

     

       101
       101
       +
           } catch (err) {

     

       102
       102
       +
             throw new ServerError(400, `Invalid verificationMethod key: ${key}`)

     

       103
       103
       +
           }

     

       104
       104
       +
         }

     

       105
       105
       +
       }

     

       106
       106
       +
       

     

       107
       107
       +
       const HOUR_LIMIT = 10

     

       108
       108
       +
       const DAY_LIMIT = 30

     

       109
       109
       +
       const WEEK_LIMIT = 100

     

       110
       110
       +
       

     

       111
       111
       +
       export const enforceOpsRateLimit = (ops: plc.IndexedOperation[]) => {

     

       112
       112
       +
         const hourAgo = new Date(Date.now() - HOUR)

     

       113
       113
       +
         const dayAgo = new Date(Date.now() - DAY)

     

       114
       114
       +
         const weekAgo = new Date(Date.now() - DAY * 7)

     

       115
       115
       +
         let withinHour = 0

     

       116
       116
       +
         let withinDay = 0

     

       117
       117
       +
         let withinWeek = 0

     

       118
       118
       +
         for (const op of ops) {

     

       119
       119
       +
           if (op.createdAt > weekAgo) {

     

       120
       120
       +
             withinWeek++

     

       121
       121
       +
             if (withinWeek >= WEEK_LIMIT) {

     

       122
       122
       +
               throw new ServerError(

     

       123
       123
       +
                 400,

     

       124
       124
       +
                 `To many operations within last week (max ${WEEK_LIMIT})`,

     

       125
       125
       +
               )

     

       126
       126
       +
             }

     

       127
       127
       +
           }

     

       128
       128
       +
           if (op.createdAt > dayAgo) {

     

       129
       129
       +
             withinDay++

     

       130
       130
       +
             if (withinDay >= DAY_LIMIT) {

     

       131
       131
       +
               throw new ServerError(

     

       132
       132
       +
                 400,

     

       133
       133
       +
                 `To many operations within last day (max ${DAY_LIMIT})`,

     

       134
       134
       +
               )

     

       135
       135
       +
             }

     

       136
       136
       +
           }

     

       137
       137
       +
           if (op.createdAt > hourAgo) {

     

       138
       138
       +
             withinHour++

     

       139
       139
       +
             if (withinHour >= HOUR_LIMIT) {

     

       140
       140
       +
               throw new ServerError(

     

       141
       141
       +
                 400,

     

       142
       142
       +
                 `To many operations within last hour (max ${HOUR_LIMIT})`,

     

       143
       143
       +
               )

     

       144
       144
       +
             }

     

       145
       145
       +
           }

     

       146
       146
       +
         }

     

       147
       147
       +
       }

packages/server/src/db/index.ts

···

       7
       7
        
       import * as migrations from '../migrations'

     

       8
       8
        
       import { DatabaseSchema, PlcDatabase } from './types'

     

       9
       9
        
       import MockDatabase from './mock'

     

       10
       10
       +
       import { enforceOpsRateLimit } from '../constraints'

     

       10
       11
        
       

     

       11
       12
        
       export * from './mock'

     

       12
       13
        
       export * from './types'

     
···

       99
       100
        
           const ops = await this.indexedOpsForDid(did)

     

       100
       101
        
           // throws if invalid

     

       101
       102
        
           const { nullified, prev } = await plc.assureValidNextOp(did, ops, proposed)

     

       103
       103
       +
           // do not enforce rate limits on recovery operations to prevent DDOS by a bad actor

     

       104
       104
       +
           if (nullified.length === 0) {

     

       105
       105
       +
             enforceOpsRateLimit(ops)

     

       106
       106
       +
           }

     

       107
       107
       +
       

     

       102
       108
        
           const cid = await cidForCbor(proposed)

     

       103
       109
        
       

     

       104
       110
        
           await this.db.transaction().execute(async (tx) => {

+2 -8

packages/server/src/routes.ts

···

       1
       1
        
       import express from 'express'

     

       2
       2
       -
       import { cborEncode, check } from '@atproto/common'

     

       3
       2
        
       import * as plc from '@did-plc/lib'

     

       4
       3
        
       import { ServerError } from './error'

     

       5
       4
        
       import { AppContext } from './context'

     

       5
       5
       +
       import { assertValidIncomingOp } from './constraints'

     

       6
       6
        
       

     

       7
       7
        
       export const createRouter = (ctx: AppContext): express.Router => {

     

       8
       8
        
         const router = express.Router()

     
···

       114
       114
        
         router.post('/:did', async function (req, res) {

     

       115
       115
        
           const { did } = req.params

     

       116
       116
        
           const op = req.body

     

       117
       117
       -
           const byteLength = cborEncode(op).byteLength

     

       118
       118
       -
           if (byteLength > 7500) {

     

       119
       119
       -
             throw new ServerError(400, 'Operation too large')

     

       120
       120
       -
           }

     

       121
       121
       -
           if (!check.is(op, plc.def.compatibleOpOrTombstone)) {

     

       122
       122
       -
             throw new ServerError(400, `Not a valid operation: ${JSON.stringify(op)}`)

     

       123
       123
       -
           }

     

       117
       117
       +
           assertValidIncomingOp(op)

     

       124
       118
        
           await ctx.db.validateAndAddOp(did, op)

     

       125
       119
        
           res.sendStatus(200)

     

       126
       120
        
         })

+19 -18

packages/server/tests/server.test.ts

···

       1
       1
       -
       import { EcdsaKeypair } from '@atproto/crypto'

     

       1
       1
       +
       import { P256Keypair } from '@atproto/crypto'

     

       2
       2
        
       import * as plc from '@did-plc/lib'

     

       3
       3
        
       import { CloseFn, runTestServer } from './_util'

     

       4
       4
        
       import { check } from '@atproto/common'

     
···

       13
       13
        
         let db: Database

     

       14
       14
        
         let client: plc.Client

     

       15
       15
        
       

     

       16
       16
       -
         let signingKey: EcdsaKeypair

     

       17
       17
       -
         let rotationKey1: EcdsaKeypair

     

       18
       18
       -
         let rotationKey2: EcdsaKeypair

     

       16
       16
       +
         let signingKey: P256Keypair

     

       17
       17
       +
         let rotationKey1: P256Keypair

     

       18
       18
       +
         let rotationKey2: P256Keypair

     

       19
       19
        
       

     

       20
       20
        
         let did: string

     

       21
       21
        
       

     
···

       27
       27
        
           db = server.db

     

       28
       28
        
           close = server.close

     

       29
       29
        
           client = new plc.Client(server.url)

     

       30
       30
       -
           signingKey = await EcdsaKeypair.create()

     

       31
       31
       -
           rotationKey1 = await EcdsaKeypair.create()

     

       32
       32
       -
           rotationKey2 = await EcdsaKeypair.create()

     

       30
       30
       +
           signingKey = await P256Keypair.create()

     

       31
       31
       +
           rotationKey1 = await P256Keypair.create()

     

       32
       32
       +
           rotationKey2 = await P256Keypair.create()

     

       33
       33
        
         })

     

       34
       34
        
       

     

       35
       35
        
         afterAll(async () => {

     
···

       70
       70
        
         })

     

       71
       71
        
       

     

       72
       72
        
         it('can perform some updates', async () => {

     

       73
       73
       -
           const newRotationKey = await EcdsaKeypair.create()

     

       74
       74
       -
           signingKey = await EcdsaKeypair.create()

     

       73
       73
       +
           const newRotationKey = await P256Keypair.create()

     

       74
       74
       +
           signingKey = await P256Keypair.create()

     

       75
       75
        
           handle = 'at://ali.example2.com'

     

       76
       76
        
           atpPds = 'https://example2.com'

     

       77
       77
        
       

     
···

       111
       111
        
         })

     

       112
       112
        
       

     

       113
       113
        
         it('rejects on bad updates', async () => {

     

       114
       114
       -
           const newKey = await EcdsaKeypair.create()

     

       114
       114
       +
           const newKey = await P256Keypair.create()

     

       115
       115
        
           const operation = client.updateAtprotoKey(did, newKey, newKey.did())

     

       116
       116
        
           await expect(operation).rejects.toThrow()

     

       117
       117
        
         })

     

       118
       118
        
       

     

       119
       119
        
         it('allows for recovery through a forked history', async () => {

     

       120
       120
       -
           const attackerKey = await EcdsaKeypair.create()

     

       120
       120
       +
           const attackerKey = await P256Keypair.create()

     

       121
       121
        
           await client.updateRotationKeys(did, rotationKey2, [attackerKey.did()])

     

       122
       122
        
       

     

       123
       123
       -
           const newKey = await EcdsaKeypair.create()

     

       123
       123
       +
           const newKey = await P256Keypair.create()

     

       124
       124
        
           const ops = await client.getOperationLog(did)

     

       125
       125
        
           const forkPoint = ops.at(-2)

     

       126
       126
        
           if (!check.is(forkPoint, plc.def.operation)) {

     
···

       158
       158
        
       

     

       159
       159
        
         it('handles concurrent requests to many docs', async () => {

     

       160
       160
        
           const COUNT = 20

     

       161
       161
       -
           const keys: EcdsaKeypair[] = []

     

       161
       161
       +
           const keys: P256Keypair[] = []

     

       162
       162
        
           for (let i = 0; i < COUNT; i++) {

     

       163
       163
       -
             keys.push(await EcdsaKeypair.create())

     

       163
       163
       +
             keys.push(await P256Keypair.create())

     

       164
       164
        
           }

     

       165
       165
        
           await Promise.all(

     

       166
       166
        
             keys.map(async (key, index) => {

     
···

       177
       177
        
       

     

       178
       178
        
         it('resolves races into a coherent history with no forks', async () => {

     

       179
       179
        
           const COUNT = 20

     

       180
       180
       -
           const keys: EcdsaKeypair[] = []

     

       180
       180
       +
           const keys: P256Keypair[] = []

     

       181
       181
        
           for (let i = 0; i < COUNT; i++) {

     

       182
       182
       -
             keys.push(await EcdsaKeypair.create())

     

       182
       182
       +
             keys.push(await P256Keypair.create())

     

       183
       183
        
           }

     

       184
       184
        
           // const prev = await client.getPrev(did)

     

       185
       185
        
       

     
···

       220
       220
        
           }

     

       221
       221
        
         })

     

       222
       222
        
       

     

       223
       223
       -
         it('still allows create v1s', async () => {

     

       223
       223
       +
         it('disallows create v1s', async () => {

     

       224
       224
        
           const createV1 = await plc.deprecatedSignCreate(

     

       225
       225
        
             {

     

       226
       226
        
               type: 'create',

     
···

       233
       233
        
             signingKey,

     

       234
       234
        
           )

     

       235
       235
        
           const did = await didForCreateOp(createV1)

     

       236
       236
       -
           await client.sendOperation(did, createV1 as any)

     

       236
       236
       +
           const attempt = client.sendOperation(did, createV1 as any)

     

       237
       237
       +
           await expect(attempt).rejects.toThrow()

     

       237
       238
        
         })

     

       238
       239
        
       

     

       239
       240
        
         it('healthcheck succeeds when database is available.', async () => {

+121 -32

yarn.lock

···

       10
       10
        
           "@jridgewell/gen-mapping" "^0.1.0"

     

       11
       11
        
           "@jridgewell/trace-mapping" "^0.3.9"

     

       12
       12
        
       

     

       13
       13
       -
       "@atproto/common@0.1.1":

     

       14
       14
       -
         version "0.1.1"

     

       15
       15
       -
         resolved "https://registry.yarnpkg.com/@atproto/common/-/common-0.1.1.tgz#ec33a3b4995c91d3ad2e90fc4cdbc65284ceff84"

     

       16
       16
       -
         integrity sha512-GYwot5wF/z8iYGSPjrLHuratLc0CVgovmwfJss7+BUOB6y2/Vw8+1Vw0n9DDI0gb5vmx3UI8z0uJgC8aa8yuJg==

     

       13
       13
       +
       "@atproto/common-web@*":

     

       14
       14
       +
         version "0.2.0"

     

       15
       15
       +
         resolved "https://registry.yarnpkg.com/@atproto/common-web/-/common-web-0.2.0.tgz#8420da28e89dac64ad2a11b6ff10a4023c67151f"

     

       16
       16
       +
         integrity sha512-ugKrT8CWf6PDsZ29VOhOCs5K4z9BAFIV7SxPXA+MHC7pINqQ+wyjIq+DtUI8kmUSce1dTqc/lMN1akf/W5whVQ==

     

       17
       17
       +
         dependencies:

     

       18
       18
       +
           graphemer "^1.4.0"

     

       19
       19
       +
           multiformats "^9.6.4"

     

       20
       20
       +
           uint8arrays "3.0.0"

     

       21
       21
       +
           zod "^3.21.4"

     

       22
       22
       +
       

     

       23
       23
       +
       "@atproto/common@0.3.0":

     

       24
       24
       +
         version "0.3.0"

     

       25
       25
       +
         resolved "https://registry.yarnpkg.com/@atproto/common/-/common-0.3.0.tgz#6ddb0a9bedbf9058353a241b056ae83539da3539"

     

       26
       26
       +
         integrity sha512-R5d50Da63wQdAYaHe+rne5nM/rSYIWBaDZtVKpluysG86U1rRIgrG4qEQ/tNDt6WzYcxKXkX4EOeVvGtav2twg==

     

       17
       27
        
         dependencies:

     

       28
       28
       +
           "@atproto/common-web" "*"

     

       18
       29
        
           "@ipld/dag-cbor" "^7.0.3"

     

       30
       30
       +
           cbor-x "^1.5.1"

     

       19
       31
        
           multiformats "^9.6.4"

     

       20
       32
        
           pino "^8.6.1"

     

       21
       21
       -
           zod "^3.14.2"

     

       22
       33
        
       

     

       23
       23
       -
       "@atproto/crypto@0.1.0":

     

       24
       24
       -
         version "0.1.0"

     

       25
       25
       -
         resolved "https://registry.yarnpkg.com/@atproto/crypto/-/crypto-0.1.0.tgz#bc73a479f9dbe06fa025301c182d7f7ab01bc568"

     

       26
       26
       -
         integrity sha512-9xgFEPtsCiJEPt9o3HtJT30IdFTGw5cQRSJVIy5CFhqBA4vDLcdXiRDLCjkzHEVbtNCsHUW6CrlfOgbeLPcmcg==

     

       34
       34
       +
       "@atproto/crypto@0.2.2":

     

       35
       35
       +
         version "0.2.2"

     

       36
       36
       +
         resolved "https://registry.yarnpkg.com/@atproto/crypto/-/crypto-0.2.2.tgz#9832dda885512a36401d24f95990489f521593ef"

     

       37
       37
       +
         integrity sha512-yepwM6pLPw/bT7Nl0nfDw251yVDpuhc0llOgD8YdCapUAH7pIn4dBcMgXiA9UzQaHA7OC9ByO5IdGPrMN/DmZw==

     

       27
       38
        
         dependencies:

     

       28
       28
       -
           "@noble/secp256k1" "^1.7.0"

     

       29
       29
       -
           big-integer "^1.6.51"

     

       30
       30
       -
           multiformats "^9.6.4"

     

       31
       31
       -
           one-webcrypto "^1.0.3"

     

       39
       39
       +
           "@noble/curves" "^1.1.0"

     

       40
       40
       +
           "@noble/hashes" "^1.3.1"

     

       32
       41
        
           uint8arrays "3.0.0"

     

       33
       42
        
       

     

       34
       43
        
       "@babel/code-frame@^7.0.0", "@babel/code-frame@^7.12.13", "@babel/code-frame@^7.18.6":

     
···

       949
       958
        
         version "0.2.3"

     

       950
       959
        
         resolved "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz"

     

       951
       960
        
         integrity sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==

     

       961
       961
       +
       

     

       962
       962
       +
       "@cbor-extract/cbor-extract-darwin-arm64@2.1.1":

     

       963
       963
       +
         version "2.1.1"

     

       964
       964
       +
         resolved "https://registry.yarnpkg.com/@cbor-extract/cbor-extract-darwin-arm64/-/cbor-extract-darwin-arm64-2.1.1.tgz#5721f6dd3feae0b96d23122853ce977e0671b7a6"

     

       965
       965
       +
         integrity sha512-blVBy5MXz6m36Vx0DfLd7PChOQKEs8lK2bD1WJn/vVgG4FXZiZmZb2GECHFvVPA5T7OnODd9xZiL3nMCv6QUhA==

     

       966
       966
       +
       

     

       967
       967
       +
       "@cbor-extract/cbor-extract-darwin-x64@2.1.1":

     

       968
       968
       +
         version "2.1.1"

     

       969
       969
       +
         resolved "https://registry.yarnpkg.com/@cbor-extract/cbor-extract-darwin-x64/-/cbor-extract-darwin-x64-2.1.1.tgz#c25e7d0133950d87d101d7b3afafea8d50d83f5f"

     

       970
       970
       +
         integrity sha512-h6KFOzqk8jXTvkOftyRIWGrd7sKQzQv2jVdTL9nKSf3D2drCvQB/LHUxAOpPXo3pv2clDtKs3xnHalpEh3rDsw==

     

       971
       971
       +
       

     

       972
       972
       +
       "@cbor-extract/cbor-extract-linux-arm64@2.1.1":

     

       973
       973
       +
         version "2.1.1"

     

       974
       974
       +
         resolved "https://registry.yarnpkg.com/@cbor-extract/cbor-extract-linux-arm64/-/cbor-extract-linux-arm64-2.1.1.tgz#48f78e7d8f0fcc84ed074b6bfa6d15dd83187c63"

     

       975
       975
       +
         integrity sha512-SxAaRcYf8S0QHaMc7gvRSiTSr7nUYMqbUdErBEu+HYA4Q6UNydx1VwFE68hGcp1qvxcy9yT5U7gA+a5XikfwSQ==

     

       976
       976
       +
       

     

       977
       977
       +
       "@cbor-extract/cbor-extract-linux-arm@2.1.1":

     

       978
       978
       +
         version "2.1.1"

     

       979
       979
       +
         resolved "https://registry.yarnpkg.com/@cbor-extract/cbor-extract-linux-arm/-/cbor-extract-linux-arm-2.1.1.tgz#7507d346389cb682e44fab8fae9534edd52e2e41"

     

       980
       980
       +
         integrity sha512-ds0uikdcIGUjPyraV4oJqyVE5gl/qYBpa/Wnh6l6xLE2lj/hwnjT2XcZCChdXwW/YFZ1LUHs6waoYN8PmK0nKQ==

     

       981
       981
       +
       

     

       982
       982
       +
       "@cbor-extract/cbor-extract-linux-x64@2.1.1":

     

       983
       983
       +
         version "2.1.1"

     

       984
       984
       +
         resolved "https://registry.yarnpkg.com/@cbor-extract/cbor-extract-linux-x64/-/cbor-extract-linux-x64-2.1.1.tgz#b7c1d2be61c58ec18d58afbad52411ded63cd4cd"

     

       985
       985
       +
         integrity sha512-GVK+8fNIE9lJQHAlhOROYiI0Yd4bAZ4u++C2ZjlkS3YmO6hi+FUxe6Dqm+OKWTcMpL/l71N6CQAmaRcb4zyJuA==

     

       986
       986
       +
       

     

       987
       987
       +
       "@cbor-extract/cbor-extract-win32-x64@2.1.1":

     

       988
       988
       +
         version "2.1.1"

     

       989
       989
       +
         resolved "https://registry.yarnpkg.com/@cbor-extract/cbor-extract-win32-x64/-/cbor-extract-win32-x64-2.1.1.tgz#21b11a1a3f18c3e7d62fd5f87438b7ed2c64c1f7"

     

       990
       990
       +
         integrity sha512-2Niq1C41dCRIDeD8LddiH+mxGlO7HJ612Ll3D/E73ZWBmycued+8ghTr/Ho3CMOWPUEr08XtyBMVXAjqF+TcKw==

     

       952
       991
        
       

     

       953
       992
        
       "@cspotcode/source-map-support@^0.8.0":

     

       954
       993
        
         version "0.8.1"

     
···

       1947
       1986
        
           npmlog "^4.1.2"

     

       1948
       1987
        
           write-file-atomic "^3.0.3"

     

       1949
       1988
        
       

     

       1950
       1950
       -
       "@noble/secp256k1@^1.7.0":

     

       1951
       1951
       -
         version "1.7.0"

     

       1952
       1952
       -
         resolved "https://registry.npmjs.org/@noble/secp256k1/-/secp256k1-1.7.0.tgz"

     

       1953
       1953
       -
         integrity sha512-kbacwGSsH/CTout0ZnZWxnW1B+jH/7r/WAAKLBtrRJ/+CUH7lgmQzl3GTrQua3SGKWNSDsS6lmjnDpIJ5Dxyaw==

     

       1989
       1989
       +
       "@noble/curves@^1.1.0":

     

       1990
       1990
       +
         version "1.2.0"

     

       1991
       1991
       +
         resolved "https://registry.yarnpkg.com/@noble/curves/-/curves-1.2.0.tgz#92d7e12e4e49b23105a2555c6984d41733d65c35"

     

       1992
       1992
       +
         integrity sha512-oYclrNgRaM9SsBUBVbb8M6DTV7ZHRTKugureoYEncY5c65HOmRzvSiTE3y5CYaPYJA/GVkrhXEoF0M3Ya9PMnw==

     

       1993
       1993
       +
         dependencies:

     

       1994
       1994
       +
           "@noble/hashes" "1.3.2"

     

       1995
       1995
       +
       

     

       1996
       1996
       +
       "@noble/hashes@1.3.2", "@noble/hashes@^1.3.1":

     

       1997
       1997
       +
         version "1.3.2"

     

       1998
       1998
       +
         resolved "https://registry.yarnpkg.com/@noble/hashes/-/hashes-1.3.2.tgz#6f26dbc8fbc7205873ce3cee2f690eba0d421b39"

     

       1999
       1999
       +
         integrity sha512-MVC8EAQp7MvEcm30KWENFjgR+Mkmf+D189XJTkFIlwohU5hcBbn1ZkKq7KVTi2Hme3PMGF390DaL52beVrIihQ==

     

       1954
       2000
        
       

     

       1955
       2001
        
       "@nodelib/fs.scandir@2.1.5":

     

       1956
       2002
        
         version "2.1.5"

     
···

       2781
       2827
        
         resolved "https://registry.npmjs.org/before-after-hook/-/before-after-hook-2.2.2.tgz"

     

       2782
       2828
        
         integrity sha512-3pZEU3NT5BFUo/AD5ERPWOgQOCZITni6iavr5AUw5AUwQjMlI0kzu5btnyD39AF0gUEsDPwJT+oY1ORBJijPjQ==

     

       2783
       2829
        
       

     

       2784
       2784
       -
       big-integer@^1.6.51:

     

       2785
       2785
       -
         version "1.6.51"

     

       2786
       2786
       -
         resolved "https://registry.npmjs.org/big-integer/-/big-integer-1.6.51.tgz"

     

       2787
       2787
       -
         integrity sha512-GPEid2Y9QU1Exl1rpO9B2IPJGHPSupF5GnVIP0blYvNOMer2bTvSWs1jGOUg04hTmu67nmLsQ9TBo1puaotBHg==

     

       2788
       2788
       -
       

     

       2789
       2830
        
       body-parser@1.20.1:

     

       2790
       2831
        
         version "1.20.1"

     

       2791
       2832
        
         resolved "https://registry.yarnpkg.com/body-parser/-/body-parser-1.20.1.tgz#b1812a8912c195cd371a3ee5e66faa2338a5c668"

     
···

       2959
       3000
        
         resolved "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz"

     

       2960
       3001
        
         integrity sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw==

     

       2961
       3002
        
       

     

       3003
       3003
       +
       cbor-extract@^2.1.1:

     

       3004
       3004
       +
         version "2.1.1"

     

       3005
       3005
       +
         resolved "https://registry.yarnpkg.com/cbor-extract/-/cbor-extract-2.1.1.tgz#f154b31529fdb6b7c70fb3ca448f44eda96a1b42"

     

       3006
       3006
       +
         integrity sha512-1UX977+L+zOJHsp0mWFG13GLwO6ucKgSmSW6JTl8B9GUvACvHeIVpFqhU92299Z6PfD09aTXDell5p+lp1rUFA==

     

       3007
       3007
       +
         dependencies:

     

       3008
       3008
       +
           node-gyp-build-optional-packages "5.0.3"

     

       3009
       3009
       +
         optionalDependencies:

     

       3010
       3010
       +
           "@cbor-extract/cbor-extract-darwin-arm64" "2.1.1"

     

       3011
       3011
       +
           "@cbor-extract/cbor-extract-darwin-x64" "2.1.1"

     

       3012
       3012
       +
           "@cbor-extract/cbor-extract-linux-arm" "2.1.1"

     

       3013
       3013
       +
           "@cbor-extract/cbor-extract-linux-arm64" "2.1.1"

     

       3014
       3014
       +
           "@cbor-extract/cbor-extract-linux-x64" "2.1.1"

     

       3015
       3015
       +
           "@cbor-extract/cbor-extract-win32-x64" "2.1.1"

     

       3016
       3016
       +
       

     

       3017
       3017
       +
       cbor-x@^1.5.1:

     

       3018
       3018
       +
         version "1.5.4"

     

       3019
       3019
       +
         resolved "https://registry.yarnpkg.com/cbor-x/-/cbor-x-1.5.4.tgz#8f0754fa8589cbd7339b613b2b5717d133508e98"

     

       3020
       3020
       +
         integrity sha512-PVKILDn+Rf6MRhhcyzGXi5eizn1i0i3F8Fe6UMMxXBnWkalq9+C5+VTmlIjAYM4iF2IYF2N+zToqAfYOp+3rfw==

     

       3021
       3021
       +
         optionalDependencies:

     

       3022
       3022
       +
           cbor-extract "^2.1.1"

     

       3023
       3023
       +
       

     

       2962
       3024
        
       cborg@^1.6.0:

     

       2963
       3025
        
         version "1.9.5"

     

       2964
       3026
        
         resolved "https://registry.npmjs.org/cborg/-/cborg-1.9.5.tgz"

     
···

       3514
       3576
        
         integrity sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==

     

       3515
       3577
        
         dependencies:

     

       3516
       3578
        
           is-obj "^2.0.0"

     

       3579
       3579
       +
       

     

       3580
       3580
       +
       dotenv@^16.0.0:

     

       3581
       3581
       +
         version "16.3.1"

     

       3582
       3582
       +
         resolved "https://registry.yarnpkg.com/dotenv/-/dotenv-16.3.1.tgz#369034de7d7e5b120972693352a3bf112172cc3e"

     

       3583
       3583
       +
         integrity sha512-IPzF4w4/Rd94bA9imS68tZBaYyBWSCE47V1RGuMrB94iyTOIEwRmVL2x/4An+6mETpLrKJ5hQkB8W4kFAadeIQ==

     

       3517
       3584
        
       

     

       3518
       3585
        
       dotenv@^16.0.3:

     

       3519
       3586
        
         version "16.0.3"

     
···

       4552
       4619
        
         resolved "https://registry.npmjs.org/grapheme-splitter/-/grapheme-splitter-1.0.4.tgz"

     

       4553
       4620
        
         integrity sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==

     

       4554
       4621
        
       

     

       4622
       4622
       +
       graphemer@^1.4.0:

     

       4623
       4623
       +
         version "1.4.0"

     

       4624
       4624
       +
         resolved "https://registry.yarnpkg.com/graphemer/-/graphemer-1.4.0.tgz#fb2f1d55e0e3a1849aeffc90c4fa0dd53a0e66c6"

     

       4625
       4625
       +
         integrity sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==

     

       4626
       4626
       +
       

     

       4555
       4627
        
       handlebars@^4.7.7:

     

       4556
       4628
        
         version "4.7.7"

     

       4557
       4629
        
         resolved "https://registry.npmjs.org/handlebars/-/handlebars-4.7.7.tgz"

     
···

       6094
       6166
        
         dependencies:

     

       6095
       6167
        
           whatwg-url "^5.0.0"

     

       6096
       6168
        
       

     

       6169
       6169
       +
       node-gyp-build-optional-packages@5.0.3:

     

       6170
       6170
       +
         version "5.0.3"

     

       6171
       6171
       +
         resolved "https://registry.yarnpkg.com/node-gyp-build-optional-packages/-/node-gyp-build-optional-packages-5.0.3.tgz#92a89d400352c44ad3975010368072b41ad66c17"

     

       6172
       6172
       +
         integrity sha512-k75jcVzk5wnnc/FMxsf4udAoTEUv2jY3ycfdSd3yWu6Cnd1oee6/CfZJApyscA4FJOmdoixWwiwOyf16RzD5JA==

     

       6173
       6173
       +
       

     

       6097
       6174
        
       node-gyp@^5.0.2:

     

       6098
       6175
        
         version "5.1.1"

     

       6099
       6176
        
         resolved "https://registry.npmjs.org/node-gyp/-/node-gyp-5.1.1.tgz"

     
···

       6365
       6442
        
         integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==

     

       6366
       6443
        
         dependencies:

     

       6367
       6444
        
           wrappy "1"

     

       6368
       6368
       -
       

     

       6369
       6369
       -
       one-webcrypto@^1.0.3:

     

       6370
       6370
       -
         version "1.0.3"

     

       6371
       6371
       -
         resolved "https://registry.npmjs.org/one-webcrypto/-/one-webcrypto-1.0.3.tgz"

     

       6372
       6372
       -
         integrity sha512-fu9ywBVBPx0gS9K0etIROTiCkvI5S1TDjFsYFb3rC1ewFxeOqsbzq7aIMBHsYfrTHBcGXJaONXXjTl8B01cW1Q==

     

       6373
       6445
        
       

     

       6374
       6446
        
       onetime@^5.1.0, onetime@^5.1.2:

     

       6375
       6447
        
         version "5.1.2"

     
···

       6782
       6854
        
         resolved "https://registry.npmjs.org/pino-std-serializers/-/pino-std-serializers-6.0.0.tgz"

     

       6783
       6855
        
         integrity sha512-mMMOwSKrmyl+Y12Ri2xhH1lbzQxwwpuru9VjyJpgFIH4asSj88F2csdMwN6+M5g1Ll4rmsYghHLQJw81tgZ7LQ==

     

       6784
       6856
        
       

     

       6785
       6785
       -
       pino@^8.0.0, pino@^8.11.0, pino@^8.6.1:

     

       6857
       6857
       +
       pino@^8.0.0, pino@^8.11.0:

     

       6786
       6858
        
         version "8.11.0"

     

       6787
       6859
        
         resolved "https://registry.yarnpkg.com/pino/-/pino-8.11.0.tgz#2a91f454106b13e708a66c74ebc1c2ab7ab38498"

     

       6788
       6860
        
         integrity sha512-Z2eKSvlrl2rH8p5eveNUnTdd4AjJk8tAsLkHYZQKGHP4WTh2Gi1cOSOs3eWPqaj+niS3gj4UkoreoaWgF3ZWYg==

     
···

       6799
       6871
        
           sonic-boom "^3.1.0"

     

       6800
       6872
        
           thread-stream "^2.0.0"

     

       6801
       6873
        
       

     

       6874
       6874
       +
       pino@^8.6.1:

     

       6875
       6875
       +
         version "8.15.0"

     

       6876
       6876
       +
         resolved "https://registry.yarnpkg.com/pino/-/pino-8.15.0.tgz#67c61d5e397bf297e5a0433976a7f7b8aa6f876b"

     

       6877
       6877
       +
         integrity sha512-olUADJByk4twxccmAxb1RiGKOSvddHugCV3wkqjyv+3Sooa2KLrmXrKEWOKi0XPCLasRR5jBXxioE1jxUa4KzQ==

     

       6878
       6878
       +
         dependencies:

     

       6879
       6879
       +
           atomic-sleep "^1.0.0"

     

       6880
       6880
       +
           fast-redact "^3.1.1"

     

       6881
       6881
       +
           on-exit-leak-free "^2.1.0"

     

       6882
       6882
       +
           pino-abstract-transport v1.0.0

     

       6883
       6883
       +
           pino-std-serializers "^6.0.0"

     

       6884
       6884
       +
           process-warning "^2.0.0"

     

       6885
       6885
       +
           quick-format-unescaped "^4.0.3"

     

       6886
       6886
       +
           real-require "^0.2.0"

     

       6887
       6887
       +
           safe-stable-stringify "^2.3.1"

     

       6888
       6888
       +
           sonic-boom "^3.1.0"

     

       6889
       6889
       +
           thread-stream "^2.0.0"

     

       6890
       6890
       +
       

     

       6802
       6891
        
       pirates@^4.0.4:

     

       6803
       6892
        
         version "4.0.5"

     

       6804
       6893
        
         resolved "https://registry.npmjs.org/pirates/-/pirates-4.0.5.tgz"

     
···

       8541
       8630
        
         resolved "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz"

     

       8542
       8631
        
         integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==

     

       8543
       8632
        
       

     

       8544
       8544
       -
       zod@^3.14.2:

     

       8545
       8545
       -
         version "3.19.1"

     

       8546
       8546
       -
         resolved "https://registry.npmjs.org/zod/-/zod-3.19.1.tgz"

     

       8547
       8547
       -
         integrity sha512-LYjZsEDhCdYET9ikFu6dVPGp2YH9DegXjdJToSzD9rO6fy4qiRYFoyEYwps88OseJlPyl2NOe2iJuhEhL7IpEA==

     

       8633
       8633
       +
       zod@^3.21.4:

     

       8634
       8634
       +
         version "3.22.2"

     

       8635
       8635
       +
         resolved "https://registry.yarnpkg.com/zod/-/zod-3.22.2.tgz#3add8c682b7077c05ac6f979fea6998b573e157b"

     

       8636
       8636
       +
         integrity sha512-wvWkphh5WQsJbVk1tbx1l1Ly4yg+XecD+Mq280uBGt9wa5BKSWf4Mhp6GmrkPixhMxmabYY7RbzlwVP32pbGCg==