···

       
91
       
 
       


     

       
92
       
 
       
export const validateOperationLog = async (

     

       
93
       
 
       
  did: string,

     

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

     

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

     

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

     

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

     
···

       
141
       
 
       


     

       
142
       
 
       
export const assureValidSig = async (

     

       
143
       
 
       
  allowedDids: string[],

     

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

     

       
145
       
 
       
): Promise<string> => {

     

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

     

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

     

···

       
91
       
 
       


     

       
92
       
 
       
export const validateOperationLog = async (

     

       
93
       
 
       
  did: string,

     

       
94
       
+
       
  ops: t.CompatibleOp[],

     

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

     

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

     

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

     
···

       
141
       
 
       


     

       
142
       
 
       
export const assureValidSig = async (

     

       
143
       
 
       
  allowedDids: string[],

     

       
144
       
+
       
  op: t.CompatibleOp,

     

       
145
       
 
       
): Promise<string> => {

     

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

     

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

     

···

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
3
       
 
       


     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
6
       
-
       
    const signingKey = await Secp256k1Keypair.create()

     

       
7
       
-
       
    const recoveryKey = await EcdsaKeypair.create()

     

       
8
       
-
       
    const handle = 'alice.test'

     

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

     

       
10
       
-
       
    const legacy = await deprecatedSignCreate(

     

       
11
       
 
       
      {

     

       
12
       
 
       
        type: 'create',

     

       
13
       
 
       
        signingKey: signingKey.did(),

     
···

       
19
       
 
       
      signingKey,

     

       
20
       
 
       
    )

     

       
21
       
 
       


     

       
22
       
-
       
    const normalized = normalizeOp(legacy)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
23
       
 
       
    expect(normalized).toEqual({

     

       
24
       
 
       
      signingKey: signingKey.did(),

     

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

     
···

       
28
       
 
       
        atpPds: service,

     

       
29
       
 
       
      },

     

       
30
       
 
       
      prev: null,

     

       
31
       
-
       
      sig: legacy.sig,

     

       
32
       
 
       
    })

     

       
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
       
 
       

     

       
33
       
 
       
  })

     

       
34
       
 
       
})

     

···

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

     

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

     

       
3
       
+
       
import {

     

       
4
       
+
       
  assureValidNextOp,

     

       
5
       
+
       
  CreateOpV1,

     

       
6
       
+
       
  deprecatedSignCreate,

     

       
7
       
+
       
  didForCreateOp,

     

       
8
       
+
       
  normalizeOp,

     

       
9
       
+
       
  signOperation,

     

       
10
       
+
       
  validateOperationLog,

     

       
11
       
+
       
} from '../src'

     

       
12
       
 
       


     

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

     

       
14
       
+
       
  let signingKey: Secp256k1Keypair

     

       
15
       
+
       
  let recoveryKey: Secp256k1Keypair

     

       
16
       
+
       
  const handle = 'alice.test'

     

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

     

       
18
       
+
       
  let did: string

     

       
19
       
+
       


     

       
20
       
+
       
  let legacyOp: CreateOpV1

     

       
21
       
+
       


     

       
22
       
+
       
  beforeAll(async () => {

     

       
23
       
+
       
    signingKey = await Secp256k1Keypair.create()

     

       
24
       
+
       
    recoveryKey = await Secp256k1Keypair.create()

     

       
25
       
+
       
  })

     

       
26
       
+
       


     

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

     

       
28
       
+
       
    legacyOp = await deprecatedSignCreate(

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
29
       
 
       
      {

     

       
30
       
 
       
        type: 'create',

     

       
31
       
 
       
        signingKey: signingKey.did(),

     
···

       
37
       
 
       
      signingKey,

     

       
38
       
 
       
    )

     

       
39
       
 
       


     

       
40
       
+
       
    did = await didForCreateOp(legacyOp)

     

       
41
       
+
       


     

       
42
       
+
       
    const normalized = normalizeOp(legacyOp)

     

       
43
       
 
       
    expect(normalized).toEqual({

     

       
44
       
 
       
      signingKey: signingKey.did(),

     

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

     
···

       
48
       
 
       
        atpPds: service,

     

       
49
       
 
       
      },

     

       
50
       
 
       
      prev: null,

     

       
51
       
+
       
      sig: legacyOp.sig,

     

       
52
       
 
       
    })

     

       
53
       
+
       
  })

     

       
54
       
+
       


     

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

     

       
56
       
+
       
    const legacyCid = await cidForCbor(legacyOp)

     

       
57
       
+
       
    const newSigner = await Secp256k1Keypair.create()

     

       
58
       
+
       
    const newRotater = await Secp256k1Keypair.create()

     

       
59
       
+
       
    const nextOp = await signOperation(

     

       
60
       
+
       
      {

     

       
61
       
+
       
        signingKey: newSigner.did(),

     

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

     

       
63
       
+
       
        handles: [handle],

     

       
64
       
+
       
        services: { atpPds: service },

     

       
65
       
+
       
        prev: legacyCid.toString(),

     

       
66
       
+
       
      },

     

       
67
       
+
       
      signingKey,

     

       
68
       
+
       
    )

     

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

     

       
70
       
+
       


     

       
71
       
+
       
    const indexedLegacy = {

     

       
72
       
+
       
      did,

     

       
73
       
+
       
      operation: legacyOp,

     

       
74
       
+
       
      cid: legacyCid,

     

       
75
       
+
       
      nullified: false,

     

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

     

       
77
       
+
       
    }

     

       
78
       
+
       


     

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

     

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

     

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

     

       
82
       
 
       
  })

     

       
83
       
 
       
})