···

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

     

       
2
       
 
       
import { Keypair } from '@atproto/crypto'

     

       
3
       
 
       
import axios from 'axios'

     

       
4
       
-
       
import { CID } from 'multiformats/cid'

     

       
5
       
-
       
import { didForCreateOp, normalizeOp, signOperation } from './operations'

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
6
       
 
       
import * as t from './types'

     

       
7
       
 
       


     

       
8
       
 
       
export class Client {

     
···

       
39
       
 
       
    return res.data

     

       
40
       
 
       
  }

     

       
41
       
 
       


     

       
42
       
-
       
  async updateData(

     

       
43
       
-
       
    did: string,

     

       
44
       
-
       
    key: Keypair,

     

       
45
       
-
       
    fn: (lastOp: t.Operation, prev: CID) => Promise<t.UnsignedOperation>,

     

       
46
       
-
       
  ) {

     

       
47
       
-
       
    const lastOp = await this.getLastOp(did)

     

       
48
       
-
       
    if (check.is(lastOp, t.def.tombstone)) {

     

       
49
       
-
       
      throw new Error('Cannot apply op to tombstone')

     

       
50
       
-
       
    }

     

       
51
       
-
       
    const normalized = normalizeOp(lastOp)

     

       
52
       
-
       
    const prev = await cidForCbor(lastOp)

     

       
53
       
-
       
    const unsigned = await fn(normalized, prev)

     

       
54
       
-
       
    const op = await signOperation(unsigned, key)

     

       
55
       
-
       
    await this.sendOperation(did, op)

     

       
56
       
-
       
  }

     

       
57
       
-
       


     

       
58
       
-
       
  async applyPartialOp(

     

       
59
       
-
       
    did: string,

     

       
60
       
-
       
    delta: Partial<t.UnsignedOperation>,

     

       
61
       
-
       
    key: Keypair,

     

       
62
       
-
       
  ) {

     

       
63
       
-
       
    await this.updateData(did, key, async (lastOp, prev) => ({

     

       
64
       
-
       
      type: 'plc_operation',

     

       
65
       
-
       
      verificationMethods: lastOp.verificationMethods,

     

       
66
       
-
       
      rotationKeys: lastOp.rotationKeys,

     

       
67
       
-
       
      alsoKnownAs: lastOp.alsoKnownAs,

     

       
68
       
-
       
      services: lastOp.services,

     

       
69
       
-
       
      prev: prev.toString(),

     

       
70
       
-
       
      ...delta,

     

       
71
       
-
       
    }))

     

       
72
       
-
       
  }

     

       
73
       
-
       


     

       
74
       
-
       
  async create(

     

       
75
       
-
       
    op: Omit<t.UnsignedOperation, 'prev'>,

     

       
76
       
-
       
    key: Keypair,

     

       
77
       
-
       
  ): Promise<string> {

     

       
78
       
-
       
    const createOp = await signOperation(

     

       
79
       
-
       
      {

     

       
80
       
-
       
        ...op,

     

       
81
       
-
       
        prev: null,

     

       
82
       
-
       
      },

     

       
83
       
-
       
      key,

     

       
84
       
-
       
    )

     

       
85
       
-
       
    const did = await didForCreateOp(createOp)

     

       
86
       
-
       
    await this.sendOperation(did, createOp)

     

       
87
       
-
       
    return did

     

       
88
       
-
       
  }

     

       
89
       
-
       


     

       
90
       
 
       
  async sendOperation(did: string, op: t.OpOrTombstone) {

     

       
91
       
 
       
    await axios.post(this.postOpUrl(did), op)

     

       
92
       
 
       
  }

     
···

       
102
       
 
       
    const res = await axios.get(url.toString())

     

       
103
       
 
       
    const lines = res.data.split('\n')

     

       
104
       
 
       
    return lines.map((l) => JSON.parse(l))

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
105
       
 
       
  }

     

       
106
       
 
       


     

       
107
       
 
       
  async health() {

     

···

       
1
       
+
       
import { check } from '@atproto/common'

     

       
2
       
 
       
import { Keypair } from '@atproto/crypto'

     

       
3
       
 
       
import axios from 'axios'

     

       
4
       
+
       
import {

     

       
5
       
+
       
  atprotoOp,

     

       
6
       
+
       
  createUpdateOp,

     

       
7
       
+
       
  didForCreateOp,

     

       
8
       
+
       
  updateAtprotoKeyOp,

     

       
9
       
+
       
  updateHandleOp,

     

       
10
       
+
       
  updatePdsOp,

     

       
11
       
+
       
  updateRotationKeysOp,

     

       
12
       
+
       
} from './operations'

     

       
13
       
 
       
import * as t from './types'

     

       
14
       
 
       


     

       
15
       
 
       
export class Client {

     
···

       
46
       
 
       
    return res.data

     

       
47
       
 
       
  }

     

       
48
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
49
       
 
       
  async sendOperation(did: string, op: t.OpOrTombstone) {

     

       
50
       
 
       
    await axios.post(this.postOpUrl(did), op)

     

       
51
       
 
       
  }

     
···

       
61
       
 
       
    const res = await axios.get(url.toString())

     

       
62
       
 
       
    const lines = res.data.split('\n')

     

       
63
       
 
       
    return lines.map((l) => JSON.parse(l))

     

       
64
       
+
       
  }

     

       
65
       
+
       


     

       
66
       
+
       
  async createDid(opts: {

     

       
67
       
+
       
    signingKey: string

     

       
68
       
+
       
    handle: string

     

       
69
       
+
       
    pds: string

     

       
70
       
+
       
    rotationKeys: string[]

     

       
71
       
+
       
    signer: Keypair

     

       
72
       
+
       
  }): Promise<string> {

     

       
73
       
+
       
    const op = await atprotoOp({ ...opts, prev: null })

     

       
74
       
+
       
    const did = await didForCreateOp(op)

     

       
75
       
+
       
    await this.sendOperation(did, op)

     

       
76
       
+
       
    return did

     

       
77
       
+
       
  }

     

       
78
       
+
       


     

       
79
       
+
       
  private async ensureLastOp(did) {

     

       
80
       
+
       
    const lastOp = await this.getLastOp(did)

     

       
81
       
+
       
    if (check.is(lastOp, t.def.tombstone)) {

     

       
82
       
+
       
      throw new Error('Cannot apply op to tombstone')

     

       
83
       
+
       
    }

     

       
84
       
+
       
    return lastOp

     

       
85
       
+
       
  }

     

       
86
       
+
       


     

       
87
       
+
       
  async updateData(

     

       
88
       
+
       
    did: string,

     

       
89
       
+
       
    signer: Keypair,

     

       
90
       
+
       
    fn: (lastOp: t.UnsignedOperation) => Omit<t.UnsignedOperation, 'prev'>,

     

       
91
       
+
       
  ) {

     

       
92
       
+
       
    const lastOp = await this.ensureLastOp(did)

     

       
93
       
+
       
    const op = await createUpdateOp(lastOp, signer, fn)

     

       
94
       
+
       
    await this.sendOperation(did, op)

     

       
95
       
+
       
  }

     

       
96
       
+
       


     

       
97
       
+
       
  async updateAtprotoKey(did: string, signer: Keypair, atprotoKey: string) {

     

       
98
       
+
       
    const lastOp = await this.ensureLastOp(did)

     

       
99
       
+
       
    const op = await updateAtprotoKeyOp(lastOp, signer, atprotoKey)

     

       
100
       
+
       
    await this.sendOperation(did, op)

     

       
101
       
+
       
  }

     

       
102
       
+
       


     

       
103
       
+
       
  async updateHandle(did: string, signer: Keypair, handle: string) {

     

       
104
       
+
       
    const lastOp = await this.ensureLastOp(did)

     

       
105
       
+
       
    const op = await updateHandleOp(lastOp, signer, handle)

     

       
106
       
+
       
    await this.sendOperation(did, op)

     

       
107
       
+
       
  }

     

       
108
       
+
       


     

       
109
       
+
       
  async updatePds(did: string, signer: Keypair, endpoint: string) {

     

       
110
       
+
       
    const lastOp = await this.ensureLastOp(did)

     

       
111
       
+
       
    const op = await updatePdsOp(lastOp, signer, endpoint)

     

       
112
       
+
       
    await this.sendOperation(did, op)

     

       
113
       
+
       
  }

     

       
114
       
+
       


     

       
115
       
+
       
  async updateRotationKeys(did: string, signer: Keypair, keys: string[]) {

     

       
116
       
+
       
    const lastOp = await this.ensureLastOp(did)

     

       
117
       
+
       
    const op = await updateRotationKeysOp(lastOp, signer, keys)

     

       
118
       
+
       
    await this.sendOperation(did, op)

     

       
119
       
 
       
  }

     

       
120
       
 
       


     

       
121
       
 
       
  async health() {

     

···

       
70
       
 
       
export const createUpdateOp = async (

     

       
71
       
 
       
  lastOp: t.CompatibleOp,

     

       
72
       
 
       
  signer: Keypair,

     

       
73
       
-
       
  fn: (

     

       
74
       
-
       
    normalized: t.UnsignedOperation,

     

       
75
       
-
       
    prev: CID,

     

       
76
       
-
       
  ) => Omit<t.UnsignedOperation, 'prev'>,

     

       
77
       
 
       
): Promise<t.Operation> => {

     

       
78
       
 
       
  const prev = await cidForCbor(lastOp)

     

       
79
       
 
       
  // omit sig so it doesn't accidentally make its way into the next operation

     

       
80
       
 
       
  const { sig, ...normalized } = normalizeOp(lastOp)

     

       
81
       
-
       
  const unsigned = await fn(normalized, prev)

     

       
82
       
 
       
  return addSignature(

     

       
83
       
 
       
    {

     

       
84
       
 
       
      ...unsigned,

     
···

       
149
       
 
       
  })

     

       
150
       
 
       
}

     

       
151
       
 
       


     

       
152
       
-
       
export const updateRotationkeysOp = async (

     

       
153
       
 
       
  lastOp: t.CompatibleOp,

     

       
154
       
 
       
  signer: Keypair,

     

       
155
       
 
       
  rotationKeys: string[],

     

···

       
70
       
 
       
export const createUpdateOp = async (

     

       
71
       
 
       
  lastOp: t.CompatibleOp,

     

       
72
       
 
       
  signer: Keypair,

     

       
73
       
+
       
  fn: (normalized: t.UnsignedOperation) => Omit<t.UnsignedOperation, 'prev'>,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
74
       
 
       
): Promise<t.Operation> => {

     

       
75
       
 
       
  const prev = await cidForCbor(lastOp)

     

       
76
       
 
       
  // omit sig so it doesn't accidentally make its way into the next operation

     

       
77
       
 
       
  const { sig, ...normalized } = normalizeOp(lastOp)

     

       
78
       
+
       
  const unsigned = await fn(normalized)

     

       
79
       
 
       
  return addSignature(

     

       
80
       
 
       
    {

     

       
81
       
 
       
      ...unsigned,

     
···

       
146
       
 
       
  })

     

       
147
       
 
       
}

     

       
148
       
 
       


     

       
149
       
+
       
export const updateRotationKeysOp = async (

     

       
150
       
 
       
  lastOp: t.CompatibleOp,

     

       
151
       
 
       
  signer: Keypair,

     

       
152
       
 
       
  rotationKeys: string[],

     

···

       
6
       
 
       
  deprecatedSignCreate,

     

       
7
       
 
       
  didForCreateOp,

     

       
8
       
 
       
  normalizeOp,

     

       
9
       
-
       
  updateRotationkeysOp,

     

       
10
       
 
       
  updateAtprotoKeyOp,

     

       
11
       
 
       
  validateOperationLog,

     

       
12
       
 
       
} from '../src'

     
···

       
68
       
 
       
      signingKey,

     

       
69
       
 
       
      newSigner.did(),

     

       
70
       
 
       
    )

     

       
71
       
-
       
    const anotherOp = await updateRotationkeysOp(nextOp, signingKey, [

     

       
72
       
 
       
      newRotater.did(),

     

       
73
       
 
       
    ])

     

       
74
       
-
       
    //   {

     

       
75
       
-
       
    //     type: 'plc_operation',

     

       
76
       
-
       
    //     verificationMethods: {

     

       
77
       
-
       
    //       atproto: newSigner.did(),

     

       
78
       
-
       
    //     },

     

       
79
       
-
       
    //     rotationKeys: [newRotater.did()],

     

       
80
       
-
       
    //     alsoKnownAs: [`at://${handle}`],

     

       
81
       
-
       
    //     services: {

     

       
82
       
-
       
    //       atproto_pds: {

     

       
83
       
-
       
    //         type: 'AtprotoPersonalDataServer',

     

       
84
       
-
       
    //         endpoint: service,

     

       
85
       
-
       
    //       },

     

       
86
       
-
       
    //     },

     

       
87
       
-
       
    //     prev: legacyCid.toString(),

     

       
88
       
-
       
    //   },

     

       
89
       
-
       
    //   signingKey,

     

       
90
       
-
       
    // )

     

       
91
       
 
       
    await validateOperationLog(did, [legacyOp, nextOp])

     

       
92
       
-
       
    // await validateOperationLog(did, [legacyOp, nextOp, anotherOp])

     

       
93
       
 
       


     

       
94
       
-
       
    return

     

       
95
       
 
       
    const indexedLegacy = {

     

       
96
       
 
       
      did,

     

       
97
       
 
       
      operation: legacyOp,

     

···

       
6
       
 
       
  deprecatedSignCreate,

     

       
7
       
 
       
  didForCreateOp,

     

       
8
       
 
       
  normalizeOp,

     

       
9
       
+
       
  updateRotationKeysOp,

     

       
10
       
 
       
  updateAtprotoKeyOp,

     

       
11
       
 
       
  validateOperationLog,

     

       
12
       
 
       
} from '../src'

     
···

       
68
       
 
       
      signingKey,

     

       
69
       
 
       
      newSigner.did(),

     

       
70
       
 
       
    )

     

       
71
       
+
       
    const anotherOp = await updateRotationKeysOp(nextOp, signingKey, [

     

       
72
       
 
       
      newRotater.did(),

     

       
73
       
 
       
    ])

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
74
       
 
       
    await validateOperationLog(did, [legacyOp, nextOp])

     

       
75
       
+
       
    await validateOperationLog(did, [legacyOp, nextOp, anotherOp])

     

       
76
       
 
       


     

       
0
       
 
       

     

       
77
       
 
       
    const indexedLegacy = {

     

       
78
       
 
       
      did,

     

       
79
       
 
       
      operation: legacyOp,

     

···

       
73
       
 
       
  })

     

       
74
       
 
       


     

       
75
       
 
       
  it('updates handle', async () => {

     

       
76
       
-
       
    handle = 'at://ali.example2.com'

     

       
77
       
-
       
    const op = await operations.updateHandleOp(lastOp(), rotationKey1, handle)

     

       
0
       
 
       

     

       
78
       
 
       
    ops.push(op)

     

       
79
       
 
       


     

       
80
       
 
       
    const doc = await data.validateOperationLog(did, ops)

     
···

       
82
       
 
       
  })

     

       
83
       
 
       


     

       
84
       
 
       
  it('updates atpPds', async () => {

     

       
85
       
-
       
    atpPds = 'https://example2.com'

     

       
86
       
-
       
    const op = await operations.updatePdsOp(lastOp(), rotationKey1, atpPds)

     

       
0
       
 
       

     

       
87
       
 
       
    ops.push(op)

     

       
88
       
 
       


     

       
89
       
 
       
    const doc = await data.validateOperationLog(did, ops)

     
···

       
107
       
 
       


     

       
108
       
 
       
  it('rotates rotation keys', async () => {

     

       
109
       
 
       
    const newRotationKey = await Secp256k1Keypair.create()

     

       
110
       
-
       
    const op = await operations.updateRotationkeysOp(lastOp(), rotationKey1, [

     

       
111
       
 
       
      newRotationKey.did(),

     

       
112
       
 
       
      rotationKey2.did(),

     

       
113
       
 
       
    ])

     

···

       
73
       
 
       
  })

     

       
74
       
 
       


     

       
75
       
 
       
  it('updates handle', async () => {

     

       
76
       
+
       
    const noPrefix = 'ali.exampl2.com'

     

       
77
       
+
       
    handle = `at://${noPrefix}`

     

       
78
       
+
       
    const op = await operations.updateHandleOp(lastOp(), rotationKey1, noPrefix)

     

       
79
       
 
       
    ops.push(op)

     

       
80
       
 
       


     

       
81
       
 
       
    const doc = await data.validateOperationLog(did, ops)

     
···

       
83
       
 
       
  })

     

       
84
       
 
       


     

       
85
       
 
       
  it('updates atpPds', async () => {

     

       
86
       
+
       
    const noPrefix = 'example2.com'

     

       
87
       
+
       
    atpPds = `https://${noPrefix}`

     

       
88
       
+
       
    const op = await operations.updatePdsOp(lastOp(), rotationKey1, noPrefix)

     

       
89
       
 
       
    ops.push(op)

     

       
90
       
 
       


     

       
91
       
 
       
    const doc = await data.validateOperationLog(did, ops)

     
···

       
109
       
 
       


     

       
110
       
 
       
  it('rotates rotation keys', async () => {

     

       
111
       
 
       
    const newRotationKey = await Secp256k1Keypair.create()

     

       
112
       
+
       
    const op = await operations.updateRotationKeysOp(lastOp(), rotationKey1, [

     

       
113
       
 
       
      newRotationKey.did(),

     

       
114
       
 
       
      rotationKey2.did(),

     

       
115
       
 
       
    ])

     

···

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

     

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

     

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

     

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

     

       
5
       
 
       
import { AxiosError } from 'axios'

     

       
6
       
 
       
import { Database } from '../src'

     

       
7
       
-
       
import { signOperation } from '@did-plc/lib'

     

       
8
       
 
       


     

       
9
       
 
       
describe('PLC server', () => {

     

       
10
       
-
       
  let handle = 'alice.example.com'

     

       
11
       
-
       
  let atpPds = 'example.com'

     

       
12
       
 
       


     

       
13
       
 
       
  let close: CloseFn

     

       
14
       
 
       
  let db: Database

     
···

       
39
       
 
       
    }

     

       
40
       
 
       
  })

     

       
41
       
 
       


     

       
42
       
-
       
  it('registers a did', async () => {

     

       
43
       
-
       
    did = await client.create(

     

       
44
       
-
       
      {

     

       
45
       
-
       
        signingKey: signingKey.did(),

     

       
46
       
-
       
        rotationKeys: [rotationKey1.did(), rotationKey2.did()],

     

       
47
       
-
       
        handles: [handle],

     

       
48
       
-
       
        services: {

     

       
49
       
-
       
          atpPds,

     

       
50
       
-
       
        },

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
51
       
 
       
      },

     

       
52
       
-
       
      rotationKey1,

     

       
53
       
-
       
    )

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
54
       
 
       
  })

     

       
55
       
 
       


     

       
56
       
 
       
  it('retrieves did doc data', async () => {

     

       
57
       
 
       
    const doc = await client.getDocumentData(did)

     

       
58
       
-
       
    expect(doc.did).toEqual(did)

     

       
59
       
-
       
    expect(doc.signingKey).toEqual(signingKey.did())

     

       
60
       
-
       
    expect(doc.rotationKeys).toEqual([rotationKey1.did(), rotationKey2.did()])

     

       
61
       
-
       
    expect(doc.handles).toEqual([handle])

     

       
62
       
-
       
    expect(doc.services).toEqual({ atpPds })

     

       
63
       
 
       
  })

     

       
64
       
 
       


     

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

     

       
66
       
 
       
    const newRotationKey = await EcdsaKeypair.create()

     

       
67
       
 
       
    signingKey = await EcdsaKeypair.create()

     

       
68
       
-
       
    handle = 'ali.example2.com'

     

       
69
       
-
       
    atpPds = 'example2.com'

     

       
70
       
 
       


     

       
71
       
-
       
    await client.applyPartialOp(

     

       
72
       
-
       
      did,

     

       
73
       
-
       
      { signingKey: signingKey.did() },

     

       
74
       
-
       
      rotationKey1,

     

       
75
       
-
       
    )

     

       
76
       
-
       


     

       
77
       
-
       
    await client.applyPartialOp(

     

       
78
       
-
       
      did,

     

       
79
       
-
       
      { rotationKeys: [newRotationKey.did(), rotationKey2.did()] },

     

       
80
       
-
       
      rotationKey1,

     

       
81
       
-
       
    )

     

       
82
       
 
       
    rotationKey1 = newRotationKey

     

       
83
       
 
       


     

       
84
       
-
       
    await client.applyPartialOp(did, { handles: [handle] }, rotationKey1)

     

       
85
       
-
       
    await client.applyPartialOp(did, { services: { atpPds } }, rotationKey1)

     

       
86
       
 
       


     

       
87
       
 
       
    const doc = await client.getDocumentData(did)

     

       
88
       
-
       
    expect(doc.did).toEqual(did)

     

       
89
       
-
       
    expect(doc.signingKey).toEqual(signingKey.did())

     

       
90
       
-
       
    expect(doc.rotationKeys).toEqual([rotationKey1.did(), rotationKey2.did()])

     

       
91
       
-
       
    expect(doc.handles).toEqual([handle])

     

       
92
       
-
       
    expect(doc.services).toEqual({ atpPds })

     

       
93
       
 
       
  })

     

       
94
       
 
       


     

       
95
       
 
       
  it('does not allow key types that we do not support', async () => {

     
···

       
97
       
 
       
    const newSigningKey =

     

       
98
       
 
       
      'did:key:z6MkjwbBXZnFqL8su24wGL2Fdjti6GSLv9SWdYGswfazUPm9'

     

       
99
       
 
       


     

       
100
       
-
       
    const promise = client.applyPartialOp(

     

       
101
       
-
       
      did,

     

       
102
       
-
       
      { signingKey: newSigningKey },

     

       
103
       
-
       
      rotationKey1,

     

       
104
       
-
       
    )

     

       
105
       
 
       
    await expect(promise).rejects.toThrow(AxiosError)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
106
       
 
       
  })

     

       
107
       
 
       


     

       
108
       
 
       
  it('retrieves the operation log', async () => {

     
···

       
114
       
 
       


     

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

     

       
116
       
 
       
    const newKey = await EcdsaKeypair.create()

     

       
117
       
-
       
    const operation = client.applyPartialOp(

     

       
118
       
-
       
      did,

     

       
119
       
-
       
      { signingKey: newKey.did() },

     

       
120
       
-
       
      newKey,

     

       
121
       
-
       
    )

     

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

     

       
123
       
 
       
  })

     

       
124
       
 
       


     

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

     

       
126
       
 
       
    const attackerKey = await EcdsaKeypair.create()

     

       
127
       
-
       
    await client.applyPartialOp(

     

       
128
       
-
       
      did,

     

       
129
       
-
       
      { signingKey: attackerKey.did(), rotationKeys: [attackerKey.did()] },

     

       
130
       
-
       
      rotationKey2,

     

       
131
       
-
       
    )

     

       
132
       
 
       


     

       
133
       
 
       
    const newKey = await EcdsaKeypair.create()

     

       
134
       
 
       
    const ops = await client.getOperationLog(did)

     
···

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

     

       
137
       
 
       
      throw new Error('Could not find fork point')

     

       
138
       
 
       
    }

     

       
139
       
-
       
    const forkCid = await cidForCbor(forkPoint)

     

       
140
       
-
       
    const op = await signOperation(

     

       
141
       
-
       
      {

     

       
142
       
-
       
        signingKey: signingKey.did(),

     

       
143
       
-
       
        rotationKeys: [newKey.did()],

     

       
144
       
-
       
        handles: forkPoint.handles,

     

       
145
       
-
       
        services: forkPoint.services,

     

       
146
       
-
       
        prev: forkCid.toString(),

     

       
147
       
-
       
      },

     

       
148
       
-
       
      rotationKey1,

     

       
149
       
-
       
    )

     

       
150
       
 
       
    await client.sendOperation(did, op)

     

       
151
       
 
       


     

       
152
       
-
       
    rotationKey1 = newKey

     

       
153
       
 
       


     

       
154
       
 
       
    const doc = await client.getDocumentData(did)

     

       
155
       
-
       
    expect(doc.did).toEqual(did)

     

       
156
       
-
       
    expect(doc.signingKey).toEqual(signingKey.did())

     

       
157
       
-
       
    expect(doc.rotationKeys).toEqual([newKey.did()])

     

       
158
       
-
       
    expect(doc.handles).toEqual([handle])

     

       
159
       
-
       
    expect(doc.services).toEqual({ atpPds })

     

       
160
       
 
       
  })

     

       
161
       
 
       


     

       
162
       
 
       
  it('retrieves the auditable operation log', async () => {

     
···

       
185
       
 
       
    }

     

       
186
       
 
       
    await Promise.all(

     

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

     

       
188
       
-
       
        await client.create(

     

       
189
       
-
       
          {

     

       
190
       
-
       
            signingKey: key.did(),

     

       
191
       
-
       
            rotationKeys: [key.did()],

     

       
192
       
-
       
            handles: [`user${index}`],

     

       
193
       
-
       
            services: {

     

       
194
       
-
       
              atpPds: `example.com`,

     

       
195
       
-
       
            },

     

       
196
       
-
       
          },

     

       
197
       
-
       
          key,

     

       
198
       
-
       
        )

     

       
199
       
 
       
      }),

     

       
200
       
 
       
    )

     

       
201
       
 
       
  })

     
···

       
213
       
 
       
    await Promise.all(

     

       
214
       
 
       
      keys.map(async (key) => {

     

       
215
       
 
       
        try {

     

       
216
       
-
       
          await client.applyPartialOp(

     

       
217
       
-
       
            did,

     

       
218
       
-
       
            { signingKey: key.did() },

     

       
219
       
-
       
            rotationKey1,

     

       
220
       
-
       
          )

     

       
221
       
 
       
          successes++

     

       
222
       
 
       
        } catch (err) {

     

       
223
       
 
       
          failures++

     

···

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

     

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

     

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

     

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

     

       
5
       
 
       
import { AxiosError } from 'axios'

     

       
6
       
 
       
import { Database } from '../src'

     

       
0
       
 
       

     

       
7
       
 
       


     

       
8
       
 
       
describe('PLC server', () => {

     

       
9
       
+
       
  let handle = 'at://alice.example.com'

     

       
10
       
+
       
  let atpPds = 'https://example.com'

     

       
11
       
 
       


     

       
12
       
 
       
  let close: CloseFn

     

       
13
       
 
       
  let db: Database

     
···

       
38
       
 
       
    }

     

       
39
       
 
       
  })

     

       
40
       
 
       


     

       
41
       
+
       
  const verifyDoc = (doc: plc.DocumentData | null) => {

     

       
42
       
+
       
    if (!doc) {

     

       
43
       
+
       
      throw new Error('expected doc')

     

       
44
       
+
       
    }

     

       
45
       
+
       
    expect(doc.did).toEqual(did)

     

       
46
       
+
       
    expect(doc.verificationMethods).toEqual({ atproto: signingKey.did() })

     

       
47
       
+
       
    expect(doc.rotationKeys).toEqual([rotationKey1.did(), rotationKey2.did()])

     

       
48
       
+
       
    expect(doc.alsoKnownAs).toEqual([handle])

     

       
49
       
+
       
    expect(doc.services).toEqual({

     

       
50
       
+
       
      atproto_pds: {

     

       
51
       
+
       
        type: 'AtprotoPersonalDataServer',

     

       
52
       
+
       
        endpoint: atpPds,

     

       
53
       
 
       
      },

     

       
54
       
+
       
    })

     

       
55
       
+
       
  }

     

       
56
       
+
       


     

       
57
       
+
       
  it('registers a did', async () => {

     

       
58
       
+
       
    did = await client.createDid({

     

       
59
       
+
       
      signingKey: signingKey.did(),

     

       
60
       
+
       
      rotationKeys: [rotationKey1.did(), rotationKey2.did()],

     

       
61
       
+
       
      handle,

     

       
62
       
+
       
      pds: atpPds,

     

       
63
       
+
       
      signer: rotationKey1,

     

       
64
       
+
       
    })

     

       
65
       
 
       
  })

     

       
66
       
 
       


     

       
67
       
 
       
  it('retrieves did doc data', async () => {

     

       
68
       
 
       
    const doc = await client.getDocumentData(did)

     

       
69
       
+
       
    verifyDoc(doc)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
70
       
 
       
  })

     

       
71
       
 
       


     

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

     

       
73
       
 
       
    const newRotationKey = await EcdsaKeypair.create()

     

       
74
       
 
       
    signingKey = await EcdsaKeypair.create()

     

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

     

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

     

       
77
       
 
       


     

       
78
       
+
       
    await client.updateAtprotoKey(did, rotationKey1, signingKey.did())

     

       
79
       
+
       
    await client.updateRotationKeys(did, rotationKey1, [

     

       
80
       
+
       
      newRotationKey.did(),

     

       
81
       
+
       
      rotationKey2.did(),

     

       
82
       
+
       
    ])

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
83
       
 
       
    rotationKey1 = newRotationKey

     

       
84
       
 
       


     

       
85
       
+
       
    await client.updateHandle(did, rotationKey1, handle)

     

       
86
       
+
       
    await client.updatePds(did, rotationKey1, atpPds)

     

       
87
       
 
       


     

       
88
       
 
       
    const doc = await client.getDocumentData(did)

     

       
89
       
+
       
    verifyDoc(doc)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
90
       
 
       
  })

     

       
91
       
 
       


     

       
92
       
 
       
  it('does not allow key types that we do not support', async () => {

     
···

       
94
       
 
       
    const newSigningKey =

     

       
95
       
 
       
      'did:key:z6MkjwbBXZnFqL8su24wGL2Fdjti6GSLv9SWdYGswfazUPm9'

     

       
96
       
 
       


     

       
97
       
+
       
    const promise = client.updateAtprotoKey(did, rotationKey1, newSigningKey)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
98
       
 
       
    await expect(promise).rejects.toThrow(AxiosError)

     

       
99
       
+
       


     

       
100
       
+
       
    const promise2 = client.updateRotationKeys(did, rotationKey1, [

     

       
101
       
+
       
      newSigningKey,

     

       
102
       
+
       
    ])

     

       
103
       
+
       
    await expect(promise2).rejects.toThrow(AxiosError)

     

       
104
       
 
       
  })

     

       
105
       
 
       


     

       
106
       
 
       
  it('retrieves the operation log', async () => {

     
···

       
112
       
 
       


     

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

     

       
114
       
 
       
    const newKey = await EcdsaKeypair.create()

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
117
       
 
       
  })

     

       
118
       
 
       


     

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

     

       
120
       
 
       
    const attackerKey = await EcdsaKeypair.create()

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
122
       
 
       


     

       
123
       
 
       
    const newKey = await EcdsaKeypair.create()

     

       
124
       
 
       
    const ops = await client.getOperationLog(did)

     
···

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

     

       
127
       
 
       
      throw new Error('Could not find fork point')

     

       
128
       
 
       
    }

     

       
129
       
+
       
    const op = await plc.updateRotationKeysOp(forkPoint, rotationKey1, [

     

       
130
       
+
       
      rotationKey1.did(),

     

       
131
       
+
       
      newKey.did(),

     

       
132
       
+
       
    ])

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
133
       
 
       
    await client.sendOperation(did, op)

     

       
134
       
 
       


     

       
135
       
+
       
    rotationKey2 = newKey

     

       
136
       
 
       


     

       
137
       
 
       
    const doc = await client.getDocumentData(did)

     

       
138
       
+
       
    verifyDoc(doc)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
139
       
 
       
  })

     

       
140
       
 
       


     

       
141
       
 
       
  it('retrieves the auditable operation log', async () => {

     
···

       
164
       
 
       
    }

     

       
165
       
 
       
    await Promise.all(

     

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

     

       
167
       
+
       
        await client.createDid({

     

       
168
       
+
       
          signingKey: key.did(),

     

       
169
       
+
       
          rotationKeys: [key.did()],

     

       
170
       
+
       
          handle: `user${index}`,

     

       
171
       
+
       
          pds: `example.com`,

     

       
172
       
+
       
          signer: key,

     

       
173
       
+
       
        })

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
174
       
 
       
      }),

     

       
175
       
 
       
    )

     

       
176
       
 
       
  })

     
···

       
188
       
 
       
    await Promise.all(

     

       
189
       
 
       
      keys.map(async (key) => {

     

       
190
       
 
       
        try {

     

       
191
       
+
       
          await client.updateAtprotoKey(did, rotationKey1, key.did())

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
192
       
 
       
          successes++

     

       
193
       
 
       
        } catch (err) {

     

       
194
       
 
       
          failures++