Key version conversion (#176)

feat: key version conversion

Allow converting legacy keys into the new key format

Author: mkobetic

package-lock.json

@@ -61,7 +61,7 @@
   "dependencies": {
     "@noble/secp256k1": "^1.5.2",
     "@stardazed/streams-polyfill": "^2.4.0",
-    "@xmtp/proto": "^3.1.0",
+    "@xmtp/proto": "^3.2.0",
     "ethers": "^5.5.3",
     "long": "^5.2.0",
     "node-localstorage": "^2.2.1"

package.json

@@ -54,7 +54,7 @@ export class SignedPrivateKey
       secp256k1Uncompressed: {
         bytes: secp.getPublicKey(secp256k1.bytes),
       },
-      createdNs: createdNs,
+      createdNs,
     })
     const signed = await signer.signKey(unsigned)
     return new SignedPrivateKey({
@@ -159,6 +159,17 @@ export class SignedPrivateKey
   static fromBytes(bytes: Uint8Array): SignedPrivateKey {
     return new SignedPrivateKey(privateKey.SignedPrivateKey.decode(bytes))
   }
+
+  static fromLegacyKey(
+    key: PrivateKey,
+    signedByWallet?: boolean
+  ): SignedPrivateKey {
+    return new SignedPrivateKey({
+      createdNs: key.timestamp.mul(1000000),
+      secp256k1: key.secp256k1,
+      publicKey: SignedPublicKey.fromLegacyKey(key.publicKey, signedByWallet),
+    })
+  }
 }
 
 // LEGACY: PrivateKey represents a secp256k1 private key.
@@ -193,7 +204,7 @@ export class PrivateKey implements privateKey.PrivateKey {
         secp256k1Uncompressed: {
           bytes: secp.getPublicKey(secp256k1.bytes),
         },
-        timestamp: timestamp,
+        timestamp,
       }),
     })
   }

src/crypto/PrivateKey.ts

@@ -22,9 +22,15 @@ function secp256k1UncompressedCheck(key: secp256k1Uncompressed): void {
   }
 }
 
+const MS_NS_TIMESTAMP_THRESHOLD = new Long(10 ** 9).mul(10 ** 9)
+
 // Basic public key without a signature.
 export class UnsignedPublicKey implements publicKey.UnsignedPublicKey {
-  createdNs: Long // time the key was generated, ns since epoch
+  // time the key was generated, normally ns since epoch, however
+  // to allow transparent conversion of pre-existing signed PublicKey to SignedPublicKey
+  // it can also be ms since epoch; use MS_NS_TIMESTAMP_THRESHOLD to distinguish
+  // the two cases.
+  createdNs: Long
   secp256k1Uncompressed: secp256k1Uncompressed // eslint-disable-line camelcase
 
   constructor(obj: publicKey.UnsignedPublicKey) {
@@ -38,7 +44,14 @@ export class UnsignedPublicKey implements publicKey.UnsignedPublicKey {
 
   // The time the key was generated.
   generated(): Date | undefined {
-    return new Date(this.createdNs.div(1000000).toNumber())
+    return new Date(this.timestamp.toNumber())
+  }
+
+  // creation time in milliseconds
+  get timestamp(): Long {
+    return this.createdNs < MS_NS_TIMESTAMP_THRESHOLD
+      ? this.createdNs
+      : this.createdNs.div(1000000)
   }
 
   // Verify that signature was created from the digest using matching private key.
@@ -155,6 +168,25 @@ export class SignedPublicKey
   static fromBytes(bytes: Uint8Array): SignedPublicKey {
     return new SignedPublicKey(publicKey.SignedPublicKey.decode(bytes))
   }
+
+  static fromLegacyKey(
+    legacyKey: PublicKey,
+    signedByWallet?: boolean
+  ): SignedPublicKey {
+    if (!legacyKey.signature) {
+      throw new Error('key is not signed')
+    }
+    let signature = legacyKey.signature
+    if (signedByWallet) {
+      signature = new Signature({
+        walletEcdsaCompact: signature.ecdsaCompact,
+      })
+    }
+    return new SignedPublicKey({
+      keyBytes: legacyKey.bytesToSign(),
+      signature,
+    })
+  }
 }
 
 // LEGACY: PublicKey optionally signed with another trusted key pair or a wallet.

src/crypto/PublicKey.ts

@@ -38,6 +38,13 @@ export class SignedPublicKeyBundle implements publicKey.SignedPublicKeyBundle {
     const decoded = publicKey.SignedPublicKeyBundle.decode(bytes)
     return new SignedPublicKeyBundle(decoded)
   }
+
+  static fromLegacyBundle(bundle: PublicKeyBundle): SignedPublicKeyBundle {
+    return new SignedPublicKeyBundle({
+      identityKey: SignedPublicKey.fromLegacyKey(bundle.identityKey),
+      preKey: SignedPublicKey.fromLegacyKey(bundle.preKey),
+    })
+  }
 }
 
 // LEGACY: PublicKeyBundle packages all the keys that a participant should advertise.

src/crypto/PublicKeyBundle.ts

@@ -11,7 +11,7 @@ import {
 } from '../../src/crypto'
 import { Wallet } from 'ethers'
 import * as secp from '@noble/secp256k1'
-import { hexToBytes } from '../../src/crypto/utils'
+import { hexToBytes, equalBytes } from '../../src/crypto/utils'
 
 describe('Crypto', function () {
   describe('Signed Keys', function () {
@@ -79,5 +79,39 @@ describe('Crypto', function () {
       const address = alice.publicKey.walletSignatureAddress()
       assert.equal(address, wallet.address)
     })
+    it('converts legacy keys to new keys', async function () {
+      // Key signed by a wallet
+      const wallet = new Wallet(PrivateKey.generate().secp256k1.bytes)
+      const identityKey = PrivateKey.generate()
+      await identityKey.publicKey.signWithWallet(wallet)
+      const iPub = identityKey.publicKey
+      assert.equal(iPub.walletSignatureAddress(), wallet.address)
+      const iPub2 = SignedPublicKey.fromLegacyKey(iPub, true)
+      assert.ok(
+        equalBytes(
+          iPub2.secp256k1Uncompressed.bytes,
+          iPub.secp256k1Uncompressed.bytes
+        )
+      )
+      assert.equal(iPub2.generated, iPub.generated)
+      assert.ok(equalBytes(iPub2.keyBytes, iPub.bytesToSign()))
+      const address = await iPub2.walletSignatureAddress()
+      assert.equal(address, wallet.address)
+
+      // Key signed by a key
+      const preKey = PrivateKey.generate()
+      await identityKey.signKey(preKey.publicKey)
+      const pPub = preKey.publicKey
+      const pPub2 = SignedPublicKey.fromLegacyKey(pPub)
+      assert.ok(
+        equalBytes(
+          pPub2.secp256k1Uncompressed.bytes,
+          pPub.secp256k1Uncompressed.bytes
+        )
+      )
+      assert.equal(pPub2.generated, pPub.generated)
+      assert.ok(equalBytes(pPub2.keyBytes, pPub.bytesToSign()))
+      assert.ok(iPub2.verifyKey(pPub2))
+    })
   })
 })