add ethers v6 support

package.json

@@ -27,7 +27,7 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "ethers": "^5.3.1",
+    "ethers": "^6.7.1",
     "tiny-invariant": "^1.3.1"
   },
   "devDependencies": {

src/allowanceTransfer.test.ts

@@ -30,7 +30,7 @@ describe('AllowanceTransfer', () => {
               token: '0x0000000000000000000000000000000000000000',
               amount: '0',
               expiration: '0',
-              nonce: MaxOrderedNonce.add(1).toString(),
+              nonce: MaxOrderedNonce + BigInt(1).toString(),
             },
             spender: '0x0000000000000000000000000000000000000000',
             sigDeadline: '0',
@@ -47,7 +47,7 @@ describe('AllowanceTransfer', () => {
           {
             details: {
               token: '0x0000000000000000000000000000000000000000',
-              amount: MaxAllowanceTransferAmount.add(1).toString(),
+              amount: MaxAllowanceTransferAmount + BigInt(1).toString(),
               expiration: '0',
               nonce: 0,
             },
@@ -67,7 +67,7 @@ describe('AllowanceTransfer', () => {
             details: {
               token: '0x0000000000000000000000000000000000000000',
               amount: '0',
-              expiration: MaxAllowanceExpiration.add(1).toString(),
+              expiration: MaxAllowanceExpiration + BigInt(1).toString(),
               nonce: 0,
             },
             spender: '0x0000000000000000000000000000000000000000',
@@ -90,7 +90,7 @@ describe('AllowanceTransfer', () => {
               nonce: 0,
             },
             spender: '0x0000000000000000000000000000000000000000',
-            sigDeadline: MaxSigDeadline.add(1).toString(),
+            sigDeadline: MaxSigDeadline + BigInt(1).toString(),
           },
           '0x0000000000000000000000000000000000000000',
           1

src/allowanceTransfer.ts

@@ -1,7 +1,5 @@
+import { BigNumberish, TypedDataDomain, TypedDataEncoder, TypedDataField } from 'ethers'
 import invariant from 'tiny-invariant'
-import { TypedDataDomain, TypedDataField } from '@ethersproject/abstract-signer'
-import { BigNumberish } from '@ethersproject/bignumber'
-import { _TypedDataEncoder } from '@ethersproject/hash'
 import { MaxSigDeadline, MaxOrderedNonce, MaxAllowanceTransferAmount, MaxAllowanceExpiration } from './constants'
 import { permit2Domain } from './domain'
 
@@ -78,7 +76,7 @@ export abstract class AllowanceTransfer {
     permit2Address: string,
     chainId: number
   ): PermitSingleData | PermitBatchData {
-    invariant(MaxSigDeadline.gte(permit.sigDeadline), 'SIG_DEADLINE_OUT_OF_RANGE')
+    invariant(MaxSigDeadline >= permit.sigDeadline, 'SIG_DEADLINE_OUT_OF_RANGE')
 
     const domain = permit2Domain(permit2Address, chainId)
     if (isPermit(permit)) {
@@ -100,12 +98,12 @@ export abstract class AllowanceTransfer {
 
   public static hash(permit: PermitSingle | PermitBatch, permit2Address: string, chainId: number): string {
     const { domain, types, values } = AllowanceTransfer.getPermitData(permit, permit2Address, chainId)
-    return _TypedDataEncoder.hash(domain, types, values)
+    return TypedDataEncoder.hash(domain, types, values)
   }
 }
 
 function validatePermitDetails(details: PermitDetails) {
-  invariant(MaxOrderedNonce.gte(details.nonce), 'NONCE_OUT_OF_RANGE')
-  invariant(MaxAllowanceTransferAmount.gte(details.amount), 'AMOUNT_OUT_OF_RANGE')
-  invariant(MaxAllowanceExpiration.gte(details.expiration), 'EXPIRATION_OUT_OF_RANGE')
+  invariant(MaxOrderedNonce >= details.nonce, 'NONCE_OUT_OF_RANGE')
+  invariant(MaxAllowanceTransferAmount >= details.amount, 'AMOUNT_OUT_OF_RANGE')
+  invariant(MaxAllowanceExpiration >= details.expiration, 'EXPIRATION_OUT_OF_RANGE')
 }

src/constants.test.ts

@@ -1,20 +1,19 @@
-import { BigNumber } from '@ethersproject/bignumber'
 import { MaxUint48, MaxUint160, MaxUint256, InstantExpiration } from './constants'
 
 describe('Constants', () => {
   it('MaxUint256', () => {
-    expect(MaxUint256).toEqual(BigNumber.from(2).pow(256).sub(1))
+    expect(MaxUint256).toEqual(BigInt(2) ** BigInt(256) - BigInt(1))
   })
 
   it('MaxUint160', () => {
-    expect(MaxUint160).toEqual(BigNumber.from(2).pow(160).sub(1))
+    expect(MaxUint160).toEqual(BigInt(2) ** BigInt(160) - BigInt(1))
   })
 
   it('MaxUint48', () => {
-    expect(MaxUint48).toEqual(BigNumber.from(2).pow(48).sub(1))
+    expect(MaxUint48).toEqual(BigInt(2) ** BigInt(48) - BigInt(1))
   })
 
   it('InstantExpiration', () => {
-    expect(InstantExpiration).toEqual(BigNumber.from(0))
+    expect(InstantExpiration).toEqual(BigInt(0))
   })
 })

src/constants.ts

@@ -1,10 +1,8 @@
-import { BigNumber } from '@ethersproject/bignumber'
-
 export const PERMIT2_ADDRESS = '0x000000000022D473030F116dDEE9F6B43aC78BA3'
 
-export const MaxUint48 = BigNumber.from('0xffffffffffff')
-export const MaxUint160 = BigNumber.from('0xffffffffffffffffffffffffffffffffffffffff')
-export const MaxUint256 = BigNumber.from('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')
+export const MaxUint48 = BigInt('0xffffffffffff')
+export const MaxUint160 = BigInt('0xffffffffffffffffffffffffffffffffffffffff')
+export const MaxUint256 = BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')
 
 // alias max types for their usages
 // allowance transfer types
@@ -17,4 +15,4 @@ export const MaxSignatureTransferAmount = MaxUint256
 export const MaxUnorderedNonce = MaxUint256
 export const MaxSigDeadline = MaxUint256
 
-export const InstantExpiration: BigNumber = BigNumber.from(0)
+export const InstantExpiration: bigint = BigInt(0)

src/domain.ts

@@ -1,4 +1,4 @@
-import { TypedDataDomain, TypedDataField } from '@ethersproject/abstract-signer'
+import { TypedDataDomain, TypedDataField } from 'ethers'
 
 const PERMIT2_DOMAIN_NAME = 'Permit2'
 

src/providers/AllowanceProvider.ts

@@ -1,10 +1,8 @@
-import { BigNumber } from '@ethersproject/bignumber'
-import { Provider } from '@ethersproject/providers'
+import { Contract, Provider } from 'ethers'
 import Permit2Abi from '../../abis/Permit2.json'
-import { Contract } from '@ethersproject/contracts'
 
 export interface AllowanceData {
-  amount: BigNumber
+  amount: bigint
   nonce: number
   expiration: number
 }
@@ -20,7 +18,7 @@ export class AllowanceProvider {
     return await this.permit2.allowance(owner, token, spender)
   }
 
-  async getAllowance(token: string, owner: string, spender: string): Promise<BigNumber> {
+  async getAllowance(token: string, owner: string, spender: string): Promise<bigint> {
     return (await this.getAllowanceData(token, owner, spender)).amount
   }
 

src/signatureTransfer.test.ts

@@ -30,7 +30,7 @@ describe('SignatureTransfer', () => {
               amount: '0',
             },
             spender: '0x0000000000000000000000000000000000000000',
-            nonce: MaxUnorderedNonce.add(1).toString(),
+            nonce: MaxUnorderedNonce + BigInt(1).toString(),
             deadline: '0',
           },
           '0x0000000000000000000000000000000000000000',
@@ -45,7 +45,7 @@ describe('SignatureTransfer', () => {
           {
             permitted: {
               token: '0x0000000000000000000000000000000000000000',
-              amount: MaxSignatureTransferAmount.add(1).toString(),
+              amount: MaxSignatureTransferAmount + BigInt(1).toString(),
             },
             spender: '0x0000000000000000000000000000000000000000',
             nonce: '0',
@@ -67,7 +67,7 @@ describe('SignatureTransfer', () => {
             },
             spender: '0x0000000000000000000000000000000000000000',
             nonce: '0',
-            deadline: MaxSigDeadline.add(1).toString(),
+            deadline: MaxSigDeadline + BigInt(1).toString(),
           },
           '0x0000000000000000000000000000000000000000',
           1

src/signatureTransfer.ts

@@ -1,9 +1,7 @@
 import invariant from 'tiny-invariant'
-import { TypedDataDomain, TypedDataField } from '@ethersproject/abstract-signer'
-import { BigNumberish } from '@ethersproject/bignumber'
-import { _TypedDataEncoder } from '@ethersproject/hash'
 import { permit2Domain } from './domain'
 import { MaxSigDeadline, MaxUnorderedNonce, MaxSignatureTransferAmount } from './constants'
+import { BigNumberish, TypedDataDomain, TypedDataEncoder, TypedDataField } from 'ethers'
 
 export interface Witness {
   witness: any
@@ -113,8 +111,8 @@ export abstract class SignatureTransfer {
     chainId: number,
     witness?: Witness
   ): PermitTransferFromData | PermitBatchTransferFromData {
-    invariant(MaxSigDeadline.gte(permit.deadline), 'SIG_DEADLINE_OUT_OF_RANGE')
-    invariant(MaxUnorderedNonce.gte(permit.nonce), 'NONCE_OUT_OF_RANGE')
+    invariant(MaxSigDeadline >= permit.deadline, 'SIG_DEADLINE_OUT_OF_RANGE')
+    invariant(MaxUnorderedNonce >= permit.nonce, 'NONCE_OUT_OF_RANGE')
 
     const domain = permit2Domain(permit2Address, chainId)
     if (isPermitTransferFrom(permit)) {
@@ -145,10 +143,10 @@ export abstract class SignatureTransfer {
     witness?: Witness
   ): string {
     const { domain, types, values } = SignatureTransfer.getPermitData(permit, permit2Address, chainId, witness)
-    return _TypedDataEncoder.hash(domain, types, values)
+    return TypedDataEncoder.hash(domain, types, values)
   }
 }
 
 function validateTokenPermissions(permissions: TokenPermissions) {
-  invariant(MaxSignatureTransferAmount.gte(permissions.amount), 'AMOUNT_OUT_OF_RANGE')
+  invariant(MaxSignatureTransferAmount >= permissions.amount, 'AMOUNT_OUT_OF_RANGE')
 }