fix(deps): update ethers to v6 (decentralized-identity#188)

BREAKING CHANGE: this update uses ethers v6 which has a sufficiently different API from v5 that will likely need attention. While the API of this library hasn't changed, it is likely that an update will need attention so this is marked as a breaking change and a new major version is released.
coincord · Sep 27, 2023 · 2785e61 · 2785e61
1 parent 836993c
commit 2785e61
Show file tree

Hide file tree

Showing 13 changed files with 1,595 additions and 2,118 deletions.
diff --git a/package.json b/package.json
@@ -83,7 +83,6 @@
     "@babel/core": "7.20.2",
     "@babel/preset-env": "7.20.2",
     "@babel/preset-typescript": "7.18.6",
-    "@ethersproject/strings": "5.7.0",
     "@semantic-release/changelog": "6.0.1",
     "@semantic-release/git": "10.0.1",
     "@types/jest": "29.2.2",
@@ -102,17 +101,7 @@
     "typescript": "4.8.4"
   },
   "dependencies": {
-    "@ethersproject/abi": "^5.6.3",
-    "@ethersproject/abstract-signer": "^5.6.2",
-    "@ethersproject/address": "^5.6.1",
-    "@ethersproject/basex": "^5.6.1",
-    "@ethersproject/bignumber": "^5.6.2",
-    "@ethersproject/bytes": "^5.6.1",
-    "@ethersproject/contracts": "^5.6.2",
-    "@ethersproject/keccak256": "^5.6.1",
-    "@ethersproject/providers": "^5.6.8",
-    "@ethersproject/signing-key": "^5.6.2",
-    "@ethersproject/transactions": "^5.6.2",
-    "did-resolver": "^4.0.1"
+    "did-resolver": "^4.0.1",
+    "ethers": "6.7.1"
   }
 }
diff --git a/src/__tests__/config.test.ts b/src/__tests__/config.test.ts
@@ -1,4 +1,4 @@
-import { InfuraProvider, JsonRpcProvider } from '@ethersproject/providers'
+import { InfuraProvider, JsonRpcProvider } from 'ethers'
 import { configureResolverWithNetworks } from '../configuration'
 
 describe('configuration', () => {
@@ -27,8 +27,8 @@ describe('configuration', () => {
       infuraProjectId: 'blabla',
       networks: [{ name: 'mainnet', rpcUrl: 'redefine me' }],
     })
-    expect((<InfuraProvider>contracts['mainnet'].provider).projectId).not.toBeDefined()
-    expect((<JsonRpcProvider>contracts['mainnet'].provider).connection.url).toBe('redefine me')
+    expect((<InfuraProvider>contracts['mainnet'].runner!.provider).projectId).not.toBeDefined()
+    expect((<JsonRpcProvider>contracts['mainnet'].runner!.provider)._getConnection().url).toBe('redefine me')
   })
 
   it('works with named network', async () => {
@@ -65,7 +65,7 @@ describe('configuration', () => {
   it('works with rpc and numbered chainId', async () => {
     const contracts = configureResolverWithNetworks({
       rpcUrl: 'some rinkeby JSONRPC URL',
-      chainId: 1,
+      chainId: BigInt(1),
     })
     expect(contracts['0x1']).toBeDefined()
   })

diff --git a/src/__tests__/nonce.test.ts b/src/__tests__/nonce.test.ts
@@ -1,10 +1,8 @@
-import { Contract, ContractFactory } from '@ethersproject/contracts'
+import { BrowserProvider, Contract, ContractFactory, getBytes, SigningKey } from 'ethers'
 import { Resolvable, Resolver } from 'did-resolver'
 import { getResolver } from '../resolver'
 import { EthrDidController } from '../controller'
 import { createProvider } from './testUtils'
-import { arrayify } from '@ethersproject/bytes'
-import { SigningKey } from '@ethersproject/signing-key'
 import { default as LegacyEthereumDIDRegistry } from './EthereumDIDRegistry-Legacy/LegacyEthereumDIDRegistry.json'
 import { default as EthereumDIDRegistry } from '../config/EthereumDIDRegistry.json'
 
@@ -24,21 +22,23 @@ describe('nonce tracking', () => {
     keyAgreementController: string,
     didResolver: Resolvable
 
-  const web3Provider = createProvider()
+  let browserProvider: BrowserProvider
 
   beforeAll(async () => {
-    const legacyFactory = ContractFactory.fromSolidity(LegacyEthereumDIDRegistry).connect(web3Provider.getSigner(0))
+    browserProvider = createProvider()
+    const legacyFactory = ContractFactory.fromSolidity(LegacyEthereumDIDRegistry).connect(
+      await browserProvider.getSigner(0)
+    )
     legacyRegistryContract = await legacyFactory.deploy()
-    legacyRegistryContract = await legacyRegistryContract.deployed()
-    await legacyRegistryContract.deployTransaction.wait()
-    const legacyRegistryAddress = legacyRegistryContract.address
+    legacyRegistryContract = await legacyRegistryContract.waitForDeployment()
+    const legacyRegistryAddress = await legacyRegistryContract.getAddress()
 
-    const factory = ContractFactory.fromSolidity(EthereumDIDRegistry).connect(web3Provider.getSigner(0))
-    registryContract = await (await factory.deploy()).deployed()
-    await registryContract.deployTransaction.wait()
-    const registryAddress = registryContract.address
+    const factory = ContractFactory.fromSolidity(EthereumDIDRegistry).connect(await browserProvider.getSigner(0))
+    registryContract = await (await factory.deploy()).waitForDeployment()
+    const registryAddress = await registryContract.getAddress()
 
-    accounts = await web3Provider.listAccounts()
+    const accountSigners = await browserProvider.listAccounts()
+    accounts = accountSigners.map((signer) => signer.address)
 
     identity = accounts[1]
     controller = accounts[2]
@@ -51,8 +51,8 @@ describe('nonce tracking', () => {
     didResolver = new Resolver(
       getResolver({
         networks: [
-          { name: 'legacy', provider: web3Provider, registry: legacyRegistryAddress },
-          { name: 'dev', provider: web3Provider, registry: registryAddress },
+          { name: 'legacy', provider: browserProvider, registry: legacyRegistryAddress },
+          { name: 'dev', provider: browserProvider, registry: registryAddress },
         ],
       })
     )
@@ -70,13 +70,13 @@ describe('nonce tracking', () => {
 
       const identifier = `did:ethr:dev:${originalOwner}`
 
-      const originalOwnerPrivateKey = arrayify('0x0000000000000000000000000000000000000000000000000000000000000002')
-      const nextOwnerPrivateKey = arrayify('0x0000000000000000000000000000000000000000000000000000000000000003')
+      const originalOwnerPrivateKey = getBytes('0x0000000000000000000000000000000000000000000000000000000000000002')
+      const nextOwnerPrivateKey = getBytes('0x0000000000000000000000000000000000000000000000000000000000000003')
 
       const ethrController = new EthrDidController(
         identifier,
         registryContract,
-        web3Provider.getSigner(signer),
+        await browserProvider.getSigner(signer),
         undefined,
         undefined,
         undefined,
@@ -85,7 +85,7 @@ describe('nonce tracking', () => {
       )
 
       const hash = await ethrController.createChangeOwnerHash(nextOwner)
-      const signature = new SigningKey(originalOwnerPrivateKey).signDigest(hash)
+      const signature = new SigningKey(originalOwnerPrivateKey).sign(hash)
 
       await ethrController.changeOwnerSigned(nextOwner, {
         sigV: signature.v,
@@ -94,18 +94,18 @@ describe('nonce tracking', () => {
       })
 
       const hash2 = await ethrController.createChangeOwnerHash(finalOwner)
-      const signature2 = new SigningKey(nextOwnerPrivateKey).signDigest(hash2)
+      const signature2 = new SigningKey(nextOwnerPrivateKey).sign(hash2)
 
       await ethrController.changeOwnerSigned(finalOwner, {
         sigV: signature2.v,
         sigR: signature2.r,
         sigS: signature2.s,
       })
 
-      const originalNonce = await registryContract.functions.nonce(originalOwner)
-      const signerNonce = await registryContract.functions.nonce(nextOwner)
-      expect(originalNonce[0]._hex).toEqual('0x01')
-      expect(signerNonce[0]._hex).toEqual('0x01')
+      const originalNonce: bigint = await registryContract.nonce(originalOwner)
+      const signerNonce: bigint = await registryContract.nonce(nextOwner)
+      expect(originalNonce).toEqual(1n)
+      expect(signerNonce).toEqual(1n)
     })
 
     it('set attribute after owner change should result in original owner wallet nonce increase', async () => {
@@ -120,13 +120,13 @@ describe('nonce tracking', () => {
 
       const identifier = `did:ethr:dev:${originalOwner}`
 
-      const originalOwnerPrivateKey = arrayify('0x0000000000000000000000000000000000000000000000000000000000000005')
-      const nextOwnerPrivateKey = arrayify('0x0000000000000000000000000000000000000000000000000000000000000006')
+      const originalOwnerPrivateKey = getBytes('0x0000000000000000000000000000000000000000000000000000000000000005')
+      const nextOwnerPrivateKey = getBytes('0x0000000000000000000000000000000000000000000000000000000000000006')
 
       const ethrController = new EthrDidController(
         identifier,
         registryContract,
-        web3Provider.getSigner(signer),
+        await browserProvider.getSigner(signer),
         undefined,
         undefined,
         undefined,
@@ -135,7 +135,7 @@ describe('nonce tracking', () => {
       )
 
       const hash = await ethrController.createChangeOwnerHash(nextOwner)
-      const signature = new SigningKey(originalOwnerPrivateKey).signDigest(hash)
+      const signature = new SigningKey(originalOwnerPrivateKey).sign(hash)
 
       await ethrController.changeOwnerSigned(nextOwner, {
         sigV: signature.v,
@@ -144,18 +144,18 @@ describe('nonce tracking', () => {
       })
 
       const hash2 = await ethrController.createSetAttributeHash(attributeName, attributeValue, attributeExpiration)
-      const signature2 = new SigningKey(nextOwnerPrivateKey).signDigest(hash2)
+      const signature2 = new SigningKey(nextOwnerPrivateKey).sign(hash2)
 
       await ethrController.setAttributeSigned(attributeName, attributeValue, attributeExpiration, {
         sigV: signature2.v,
         sigR: signature2.r,
         sigS: signature2.s,
       })
 
-      const originalNonce = await registryContract.functions.nonce(originalOwner)
-      const signerNonce = await registryContract.functions.nonce(nextOwner)
-      expect(originalNonce[0]._hex).toEqual('0x01')
-      expect(signerNonce[0]._hex).toEqual('0x01')
+      const originalNonce = await registryContract.nonce(originalOwner)
+      const signerNonce = await registryContract.nonce(nextOwner)
+      expect(originalNonce).toEqual(1n)
+      expect(signerNonce).toEqual(1n)
     })
   })
   describe('legacy contract', () => {
@@ -171,39 +171,41 @@ describe('nonce tracking', () => {
 
       const identifier = `did:ethr:legacy:${originalOwner}`
 
-      const originalOwnerPrivateKey = arrayify('0x0000000000000000000000000000000000000000000000000000000000000002')
-      const nextOwnerPrivateKey = arrayify('0x0000000000000000000000000000000000000000000000000000000000000003')
+      const originalOwnerPrivateKey = getBytes('0x0000000000000000000000000000000000000000000000000000000000000002')
+      const nextOwnerPrivateKey = getBytes('0x0000000000000000000000000000000000000000000000000000000000000003')
 
       const hash = await new EthrDidController(identifier, legacyRegistryContract).createChangeOwnerHash(nextOwner)
-      const signature = new SigningKey(originalOwnerPrivateKey).signDigest(hash)
-
-      await new EthrDidController(identifier, legacyRegistryContract, web3Provider.getSigner(signer)).changeOwnerSigned(
-        nextOwner,
-        {
-          sigV: signature.v,
-          sigR: signature.r,
-          sigS: signature.s,
-        }
-      )
+      const signature = new SigningKey(originalOwnerPrivateKey).sign(hash)
+
+      await new EthrDidController(
+        identifier,
+        legacyRegistryContract,
+        await browserProvider.getSigner(signer)
+      ).changeOwnerSigned(nextOwner, {
+        sigV: signature.v,
+        sigR: signature.r,
+        sigS: signature.s,
+      })
 
       const hash2 = await new EthrDidController(identifier, legacyRegistryContract).createChangeOwnerHash(finalOwner)
-      const signature2 = new SigningKey(nextOwnerPrivateKey).signDigest(hash2)
-
-      await new EthrDidController(identifier, legacyRegistryContract, web3Provider.getSigner(signer)).changeOwnerSigned(
-        finalOwner,
-        {
-          sigV: signature2.v,
-          sigR: signature2.r,
-          sigS: signature2.s,
-        }
-      )
+      const signature2 = new SigningKey(nextOwnerPrivateKey).sign(hash2)
+
+      await new EthrDidController(
+        identifier,
+        legacyRegistryContract,
+        await browserProvider.getSigner(signer)
+      ).changeOwnerSigned(finalOwner, {
+        sigV: signature2.v,
+        sigR: signature2.r,
+        sigS: signature2.s,
+      })
 
       // Expect the nonce of the original identity to equal 2 as the nonce tracking in the legacy contract is
       // done on an identity basis
-      const originalNonce = await legacyRegistryContract.functions.nonce(originalOwner)
-      const signerNonce = await legacyRegistryContract.functions.nonce(nextOwner)
-      expect(originalNonce[0]._hex).toEqual('0x02')
-      expect(signerNonce[0]._hex).toEqual('0x00')
+      const originalNonce = await legacyRegistryContract.nonce(originalOwner)
+      const signerNonce = await legacyRegistryContract.nonce(nextOwner)
+      expect(originalNonce).toEqual(2n)
+      expect(signerNonce).toEqual(0n)
     })
 
     it('set attribute after owner change should result in original owner wallet nonce increase', async () => {
@@ -218,41 +220,42 @@ describe('nonce tracking', () => {
 
       const identifier = `did:ethr:legacy:${originalOwner}`
 
-      const originalOwnerPrivateKey = arrayify('0x0000000000000000000000000000000000000000000000000000000000000005')
-      const nextOwnerPrivateKey = arrayify('0x0000000000000000000000000000000000000000000000000000000000000006')
+      const originalOwnerPrivateKey = getBytes('0x0000000000000000000000000000000000000000000000000000000000000005')
+      const nextOwnerPrivateKey = getBytes('0x0000000000000000000000000000000000000000000000000000000000000006')
 
       const hash = await new EthrDidController(identifier, legacyRegistryContract).createChangeOwnerHash(nextOwner)
-      const signature = new SigningKey(originalOwnerPrivateKey).signDigest(hash)
-
-      await new EthrDidController(identifier, legacyRegistryContract, web3Provider.getSigner(signer)).changeOwnerSigned(
-        nextOwner,
-        {
-          sigV: signature.v,
-          sigR: signature.r,
-          sigS: signature.s,
-        }
-      )
+      const signature = new SigningKey(originalOwnerPrivateKey).sign(hash)
+
+      await new EthrDidController(
+        identifier,
+        legacyRegistryContract,
+        await browserProvider.getSigner(signer)
+      ).changeOwnerSigned(nextOwner, {
+        sigV: signature.v,
+        sigR: signature.r,
+        sigS: signature.s,
+      })
 
       const hash2 = await new EthrDidController(identifier, legacyRegistryContract).createSetAttributeHash(
         attributeName,
         attributeValue,
         attributeExpiration
       )
-      const signature2 = new SigningKey(nextOwnerPrivateKey).signDigest(hash2)
+      const signature2 = new SigningKey(nextOwnerPrivateKey).sign(hash2)
 
       await new EthrDidController(
         identifier,
         legacyRegistryContract,
-        web3Provider.getSigner(signer)
+        await browserProvider.getSigner(signer)
       ).setAttributeSigned(attributeName, attributeValue, attributeExpiration, {
         sigV: signature2.v,
         sigR: signature2.r,
         sigS: signature2.s,
       })
 
-      const nonce = await legacyRegistryContract.functions.nonce(originalOwner)
+      const nonce = await legacyRegistryContract.nonce(originalOwner)
 
-      expect(nonce[0]._hex).toEqual('0x02')
+      expect(nonce).toEqual(2n)
     })
   })
 })