commit b0a55dabc7741aa2ef656b5fb681d6bfecf9a262 · edouard.paris/did-method-plc

+2 -2

packages/lib/src/data.ts

···

       91
       91
        
       

     

       92
       92
        
       export const validateOperationLog = async (

     

       93
       93
        
         did: string,

     

       94
       94
       -
         ops: (t.CreateOpV1 | t.Operation)[],

     

       94
       94
       +
         ops: t.CompatibleOp[],

     

       95
       95
        
       ): Promise<t.DocumentData> => {

     

       96
       96
        
         // make sure they're all validly formatted operations

     

       97
       97
        
         const [first, ...rest] = ops

     
···

       141
       141
        
       

     

       142
       142
        
       export const assureValidSig = async (

     

       143
       143
        
         allowedDids: string[],

     

       144
       144
       -
         op: t.CreateOpV1 | t.Operation,

     

       144
       144
       +
         op: t.CompatibleOp,

     

       145
       145
        
       ): Promise<string> => {

     

       146
       146
        
         const { sig, ...opData } = op

     

       147
       147
        
         const sigBytes = uint8arrays.fromString(sig, 'base64url')

+58 -9

packages/lib/tests/compatibility.test.ts

···

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

     

       2
       2
       -
       import { deprecatedSignCreate, normalizeOp } from '../src'

     

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

     

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

     

       3
       3
       +
       import {

     

       4
       4
       +
         assureValidNextOp,

     

       5
       5
       +
         CreateOpV1,

     

       6
       6
       +
         deprecatedSignCreate,

     

       7
       7
       +
         didForCreateOp,

     

       8
       8
       +
         normalizeOp,

     

       9
       9
       +
         signOperation,

     

       10
       10
       +
         validateOperationLog,

     

       11
       11
       +
       } from '../src'

     

       3
       12
        
       

     

       4
       13
        
       describe('compatibility', () => {

     

       14
       14
       +
         let signingKey: Secp256k1Keypair

     

       15
       15
       +
         let recoveryKey: Secp256k1Keypair

     

       16
       16
       +
         const handle = 'alice.test'

     

       17
       17
       +
         const service = 'https://example.com'

     

       18
       18
       +
         let did: string

     

       19
       19
       +
       

     

       20
       20
       +
         let legacyOp: CreateOpV1

     

       21
       21
       +
       

     

       22
       22
       +
         beforeAll(async () => {

     

       23
       23
       +
           signingKey = await Secp256k1Keypair.create()

     

       24
       24
       +
           recoveryKey = await Secp256k1Keypair.create()

     

       25
       25
       +
         })

     

       26
       26
       +
       

     

       5
       27
        
         it('normalizes legacy create ops', async () => {

     

       6
       6
       -
           const signingKey = await Secp256k1Keypair.create()

     

       7
       7
       -
           const recoveryKey = await EcdsaKeypair.create()

     

       8
       8
       -
           const handle = 'alice.test'

     

       9
       9
       -
           const service = 'https://example.com'

     

       10
       10
       -
           const legacy = await deprecatedSignCreate(

     

       28
       28
       +
           legacyOp = await deprecatedSignCreate(

     

       11
       29
        
             {

     

       12
       30
        
               type: 'create',

     

       13
       31
        
               signingKey: signingKey.did(),

     
···

       19
       37
        
             signingKey,

     

       20
       38
        
           )

     

       21
       39
        
       

     

       22
       22
       -
           const normalized = normalizeOp(legacy)

     

       40
       40
       +
           did = await didForCreateOp(legacyOp)

     

       41
       41
       +
       

     

       42
       42
       +
           const normalized = normalizeOp(legacyOp)

     

       23
       43
        
           expect(normalized).toEqual({

     

       24
       44
        
             signingKey: signingKey.did(),

     

       25
       45
        
             rotationKeys: [recoveryKey.did(), signingKey.did()],

     
···

       28
       48
        
               atpPds: service,

     

       29
       49
        
             },

     

       30
       50
        
             prev: null,

     

       31
       31
       -
             sig: legacy.sig,

     

       51
       51
       +
             sig: legacyOp.sig,

     

       32
       52
        
           })

     

       53
       53
       +
         })

     

       54
       54
       +
       

     

       55
       55
       +
         it('validates a log with a legacy create op', async () => {

     

       56
       56
       +
           const legacyCid = await cidForCbor(legacyOp)

     

       57
       57
       +
           const newSigner = await Secp256k1Keypair.create()

     

       58
       58
       +
           const newRotater = await Secp256k1Keypair.create()

     

       59
       59
       +
           const nextOp = await signOperation(

     

       60
       60
       +
             {

     

       61
       61
       +
               signingKey: newSigner.did(),

     

       62
       62
       +
               rotationKeys: [newRotater.did()],

     

       63
       63
       +
               handles: [handle],

     

       64
       64
       +
               services: { atpPds: service },

     

       65
       65
       +
               prev: legacyCid.toString(),

     

       66
       66
       +
             },

     

       67
       67
       +
             signingKey,

     

       68
       68
       +
           )

     

       69
       69
       +
           await validateOperationLog(did, [legacyOp, nextOp])

     

       70
       70
       +
       

     

       71
       71
       +
           const indexedLegacy = {

     

       72
       72
       +
             did,

     

       73
       73
       +
             operation: legacyOp,

     

       74
       74
       +
             cid: legacyCid,

     

       75
       75
       +
             nullified: false,

     

       76
       76
       +
             createdAt: new Date(Date.now() - 7 * DAY),

     

       77
       77
       +
           }

     

       78
       78
       +
       

     

       79
       79
       +
           const result = await assureValidNextOp(did, [indexedLegacy], nextOp)

     

       80
       80
       +
           expect(result.nullified.length).toBe(0)

     

       81
       81
       +
           expect(result.prev?.equals(legacyCid))

     

       33
       82
        
         })

     

       34
       83
        
       })