@0xsequence/provider 1.10.15 → 2.0.0

package/src/extended.ts

@@ -1,10 +1,10 @@
 import { ethers } from 'ethers'
 
-export type ExtendedTransactionRequest = ethers.providers.TransactionRequest & {
-  auxiliary?: ethers.providers.TransactionRequest[]
+export type ExtendedTransactionRequest = ethers.TransactionRequest & {
+  auxiliary?: ethers.TransactionRequest[]
 }
 
-export function toExtended(transactions: ethers.providers.TransactionRequest[]): ExtendedTransactionRequest {
+export function toExtended(transactions: ethers.TransactionRequest[]): ExtendedTransactionRequest {
   if (transactions.length === 0) {
     throw new Error('No transaction provided')
   }
@@ -17,10 +17,10 @@ export function toExtended(transactions: ethers.providers.TransactionRequest[]):
   }
 }
 
-export function fromExtended(transaction: ExtendedTransactionRequest): ethers.providers.TransactionRequest[] {
+export function fromExtended(transaction: ExtendedTransactionRequest): ethers.TransactionRequest[] {
   return [transaction, ...(transaction.auxiliary || [])]
 }
 
-export function isExtended(transaction: ethers.providers.TransactionRequest): transaction is ExtendedTransactionRequest {
+export function isExtended(transaction: ethers.TransactionRequest): transaction is ExtendedTransactionRequest {
   return (transaction as any).auxiliary !== undefined
 }

package/src/init.ts

@@ -1,13 +1,12 @@
 import {
   CachedProvider,
   ChainIdLike,
-  JsonRpcRouter,
-  JsonRpcSender,
   NetworkConfig,
   allNetworks,
   exceptionProviderMiddleware,
   findNetworkConfig,
-  loggingProviderMiddleware
+  loggingProviderMiddleware,
+  JsonRpcProvider
 } from '@0xsequence/network'
 import { MuxTransportTemplate } from './transports'
 import { ItemStore, useBestStore } from './utils'
@@ -85,7 +84,7 @@ export const initWallet = (projectAccessKey: string, partialConfig?: Partial<Pro
     }
   }
 
-  const rpcProviders: Record<number, ethers.providers.JsonRpcProvider> = {}
+  const rpcProviders: Record<number, ethers.JsonRpcProvider> = {}
 
   // Find any new networks that aren't already defined in sequence.js
   // and add them to the list of networks, (they must have a rpcUrl and chainId)
@@ -120,13 +119,13 @@ export const initWallet = (projectAccessKey: string, partialConfig?: Partial<Pro
         throw new Error(`no rpcUrl found for chainId: ${chainId}`)
       }
 
-      const baseProvider = new ethers.providers.JsonRpcProvider(rpcUrl)
-      const router = new JsonRpcRouter(
-        [loggingProviderMiddleware, exceptionProviderMiddleware, new CachedProvider()],
-        new JsonRpcSender(baseProvider)
+      rpcProviders[chainId] = new JsonRpcProvider(
+        rpcUrl,
+        {
+          middlewares: [loggingProviderMiddleware, exceptionProviderMiddleware, new CachedProvider()]
+        },
+        { cacheTimeout: -1 }
       )
-
-      rpcProviders[chainId] = new ethers.providers.Web3Provider(router, chainId)
     }
 
     return rpcProviders[chainId]

package/src/provider.ts

@@ -1,7 +1,7 @@
 import { ethers } from 'ethers'
 import { SequenceClient } from './client'
-import { ChainIdLike, NetworkConfig, allNetworks, findNetworkConfig } from '@0xsequence/network'
-import { ConnectDetails, ConnectOptions, EIP1193Provider, OpenWalletIntent, OptionalChainIdLike, WalletSession } from './types'
+import { EIP1193Provider, ChainIdLike, NetworkConfig, allNetworks, findNetworkConfig } from '@0xsequence/network'
+import { ConnectDetails, ConnectOptions, OpenWalletIntent, OptionalChainIdLike, WalletSession } from './types'
 import { commons } from '@0xsequence/core'
 import { WalletUtils } from './utils/index'
 import { SequenceSigner, SingleNetworkSequenceSigner } from './signer'
@@ -46,7 +46,10 @@ export interface ISequenceProvider {
   utils: WalletUtils
 }
 
-export class SequenceProvider extends ethers.providers.BaseProvider implements ISequenceProvider, EIP1193Provider {
+const EIP1193EventTypes = ['connect', 'disconnect', 'chainChanged', 'accountsChanged'] as const
+type EIP1193EventType = (typeof EIP1193EventTypes)[number]
+
+export class SequenceProvider extends ethers.AbstractProvider implements ISequenceProvider, EIP1193Provider {
   private readonly singleNetworkProviders: { [chainId: number]: SingleNetworkSequenceProvider } = {}
 
   readonly _isSequenceProvider = true
@@ -54,30 +57,37 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
 
   readonly signer: SequenceSigner
 
+  readonly eip1193EventListeners = new Map<EIP1193EventType, Set<ethers.Listener>>()
+
   constructor(
     public readonly client: SequenceClient,
-    private readonly providerFor: (networkId: number) => ethers.providers.JsonRpcProvider,
-    public readonly networks: NetworkConfig[] = allNetworks
+    private readonly providerFor: (networkId: number) => ethers.JsonRpcProvider,
+    public readonly networks: NetworkConfig[] = allNetworks,
+    public readonly options?: ethers.AbstractProviderOptions
   ) {
     // We support a lot of networks
     // but we start with the default one
-    super(client.getChainId())
+    super(client.getChainId(), options)
 
     // Emit events as defined by EIP-1193
     client.onConnect(details => {
-      this.emit('connect', details)
+      //this.emit('connect', details)
+      this.eip1193EventListeners.get('connect')?.forEach(listener => listener(details))
     })
 
     client.onDisconnect(error => {
-      this.emit('disconnect', error)
+      //this.emit('disconnect', error)
+      this.eip1193EventListeners.get('disconnect')?.forEach(listener => listener(error))
     })
 
     client.onDefaultChainIdChanged(chainId => {
-      this.emit('chainChanged', chainId)
+      //this.emit('chainChanged', chainId)
+      this.eip1193EventListeners.get('chainChanged')?.forEach(listener => listener(chainId))
     })
 
     client.onAccountsChanged(accounts => {
-      this.emit('accountsChanged', accounts)
+      //this.emit('accountsChanged', accounts)
+      this.eip1193EventListeners.get('accountsChanged')?.forEach(listener => listener(accounts))
     })
 
     // NOTICE: We don't emit 'open' and 'close' events
@@ -95,6 +105,36 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
     this.utils = new WalletUtils(this.signer)
   }
 
+  async on(event: ethers.ProviderEvent | EIP1193EventType, listener: ethers.Listener): Promise<this> {
+    if (EIP1193EventTypes.includes(event as EIP1193EventType)) {
+      const listeners = this.eip1193EventListeners.get(event as EIP1193EventType) || new Set()
+      listeners.add(listener)
+      this.eip1193EventListeners.set(event as EIP1193EventType, listeners)
+
+      return this
+    }
+
+    return super.on(event, listener) as Promise<this>
+  }
+
+  async off(event: ethers.ProviderEvent | EIP1193EventType, listener?: ethers.Listener | undefined): Promise<this> {
+    if (EIP1193EventTypes.includes(event as EIP1193EventType)) {
+      const listeners = this.eip1193EventListeners.get(event as EIP1193EventType)
+
+      if (listeners) {
+        if (listener) {
+          listeners.delete(listener)
+        } else {
+          listeners.clear()
+        }
+      }
+
+      return this
+    }
+
+    return super.off(event, listener) as Promise<this>
+  }
+
   getSigner(): SequenceSigner
   getSigner(chainId: ChainIdLike): SingleNetworkSequenceSigner
   getSigner(chainId?: ChainIdLike): SequenceSigner | SingleNetworkSequenceSigner
@@ -206,13 +246,18 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
   getProvider(chainId?: ChainIdLike) {
     // The provider without a chainId is... this one
     if (!chainId) {
-      return this
+      return this as SequenceProvider
     }
 
     const useChainId = this.toChainId(chainId)
 
     if (!this.singleNetworkProviders[useChainId]) {
-      this.singleNetworkProviders[useChainId] = new SingleNetworkSequenceProvider(this.client, this.providerFor, useChainId)
+      this.singleNetworkProviders[useChainId] = new SingleNetworkSequenceProvider(
+        this.client,
+        this.providerFor,
+        useChainId,
+        this.options
+      )
     }
 
     return this.singleNetworkProviders[useChainId]
@@ -222,7 +267,7 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
    *  This returns a subprovider, this is a regular non-sequence provider that
    *  can be used to fulfill read only requests on a given network.
    */
-  async _getSubprovider(chainId?: ChainIdLike): Promise<ethers.providers.JsonRpcProvider> {
+  async _getSubprovider(chainId?: ChainIdLike): Promise<ethers.JsonRpcProvider> {
     const useChainId = await this.useChainId(chainId)
 
     // Whoever implements providerFrom should memoize the generated provider
@@ -236,10 +281,23 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
     return provider
   }
 
+  async _perform(req: ethers.PerformActionRequest): Promise<any> {
+    const { method, ...args } = req
+
+    const provider = await this._getSubprovider()
+    const prepared = provider.getRpcRequest(req) ?? { method, args: Object.values(args) }
+
+    if (!prepared) {
+      throw new Error(`Unsupported method ${req.method}`)
+    }
+
+    return provider.send(prepared.method, prepared.args)
+  }
+
   async perform(method: string, params: any): Promise<any> {
     // First we check if the method should be handled by the client
     if (method === 'eth_chainId') {
-      return ethers.utils.hexValue(await this.useChainId())
+      return ethers.toQuantity(await this.useChainId())
     }
 
     if (method === 'eth_accounts') {
@@ -268,14 +326,10 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
     ) {
       // We pass the chainId to the client, if we don't pass one
       // the client will use its own default chainId
-      return this.client.send({ method, params }, this.getChainId())
+      return this.client.request({ method, params, chainId: this.getChainId() })
     }
 
-    // Forward call to the corresponding provider
-    // we use the provided chainId, or the default one provided by the client
-    const provider = await this._getSubprovider()
-    const prepared = provider.prepareRequest(method, params) ?? [method, params]
-    return provider.send(prepared[0], prepared[1])
+    return this._perform({ method, ...params })
   }
 
   send(method: string, params: any): Promise<any> {
@@ -286,17 +340,23 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
     return this.perform(request.method, request.params)
   }
 
-  async detectNetwork(): Promise<ethers.providers.Network> {
+  async _detectNetwork(): Promise<ethers.Network> {
     const chainId = this.client.getChainId()
-    const network = findNetworkConfig(this.networks, chainId)
+    const found = findNetworkConfig(this.networks, chainId)
 
-    if (!network) {
+    if (!found) {
       throw new Error(`Unknown network ${chainId}`)
     }
 
+    const network = new ethers.Network(found.name, found.chainId)
+
     return network
   }
 
+  async detectNetwork(): Promise<ethers.Network> {
+    return this._detectNetwork()
+  }
+
   // Override most of the methods, so we add support for an optional chainId
   // argument, which is used to select the provider to use.
   //
@@ -314,76 +374,61 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
     return provider.getBlockNumber()
   }
 
-  async getGasPrice(optionals?: OptionalChainIdLike) {
+  async getFeeData(optionals?: OptionalChainIdLike) {
     const provider = await this._getSubprovider(optionals?.chainId)
-    return provider.getGasPrice()
+    return provider.getFeeData()
   }
 
-  async getBalance(
-    addressOrName: string | Promise<string>,
-    blockTag?: ethers.providers.BlockTag | Promise<ethers.providers.BlockTag>,
-    optionals?: OptionalChainIdLike
-  ) {
+  async getBalance(addressOrName: string | Promise<string>, blockTag?: ethers.BlockTag, optionals?: OptionalChainIdLike) {
     const provider = await this._getSubprovider(optionals?.chainId)
     return provider.getBalance(addressOrName, blockTag)
   }
 
   async getTransactionCount(
     addressOrName: string | Promise<string>,
-    blockTag?: ethers.providers.BlockTag | Promise<ethers.providers.BlockTag>,
+    blockTag?: ethers.BlockTag,
     optionals?: OptionalChainIdLike
   ) {
     const provider = await this._getSubprovider(optionals?.chainId)
     return provider.getTransactionCount(addressOrName, blockTag)
   }
 
-  async getCode(
-    addressOrName: string | Promise<string>,
-    blockTag?: ethers.providers.BlockTag | Promise<ethers.providers.BlockTag>,
-    optionals?: OptionalChainIdLike
-  ) {
+  async getCode(addressOrName: string | Promise<string>, blockTag?: ethers.BlockTag, optionals?: OptionalChainIdLike) {
     const provider = await this._getSubprovider(optionals?.chainId)
     return provider.getCode(addressOrName, blockTag)
   }
 
-  async getStorageAt(
+  async getStorage(
     addressOrName: string | Promise<string>,
-    position: ethers.BigNumberish | Promise<ethers.BigNumberish>,
-    blockTag?: ethers.providers.BlockTag | Promise<ethers.providers.BlockTag>,
+    position: ethers.BigNumberish,
+    blockTag?: ethers.BlockTag,
     optionals?: OptionalChainIdLike
   ) {
     const provider = await this._getSubprovider(optionals?.chainId)
-    return provider.getStorageAt(addressOrName, position, blockTag)
+    return provider.getStorage(addressOrName, position, blockTag)
   }
 
-  async call(
-    transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>,
-    blockTag?: ethers.providers.BlockTag | Promise<ethers.providers.BlockTag>,
-    optionals?: OptionalChainIdLike
-  ) {
+  async call(transaction: ethers.TransactionRequest, optionals?: OptionalChainIdLike) {
     const provider = await this._getSubprovider(optionals?.chainId)
-    return provider.call(transaction, blockTag)
+    return provider.call(transaction)
   }
 
-  async estimateGas(transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>, optionals?: OptionalChainIdLike) {
+  async estimateGas(transaction: ethers.TransactionRequest, optionals?: OptionalChainIdLike) {
     const provider = await this._getSubprovider(optionals?.chainId)
     return provider.estimateGas(transaction)
   }
 
-  async getBlock(
-    blockHashOrBlockTag: ethers.providers.BlockTag | string | Promise<ethers.providers.BlockTag | string>,
-    optionals?: OptionalChainIdLike
-  ) {
+  async getBlock(blockHashOrBlockTag: ethers.BlockTag | string, prefetchTxs?: boolean, optionals?: OptionalChainIdLike) {
     const provider = await this._getSubprovider(optionals?.chainId)
-    return provider.getBlock(blockHashOrBlockTag)
+    return provider.getBlock(blockHashOrBlockTag, prefetchTxs)
   }
 
-  async getTransaction(transactionHash: string | Promise<string>, optionals?: OptionalChainIdLike) {
+  async getTransaction(transactionHash: string, optionals?: OptionalChainIdLike) {
     const provider = await this._getSubprovider(optionals?.chainId)
     return provider.getTransaction(transactionHash)
   }
 
-  async getLogs(filter: ethers.providers.Filter | Promise<ethers.providers.Filter>, optionals?: OptionalChainIdLike) {
+  async getLogs(filter: ethers.Filter, optionals?: OptionalChainIdLike) {
     const provider = await this._getSubprovider(optionals?.chainId)
     return provider.getLogs(filter)
   }
@@ -405,8 +450,8 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
     return provider.getResolver(name)
   }
 
-  async resolveName(name: string | Promise<string>) {
-    if (ethers.utils.isAddress(await name)) {
+  async resolveName(name: string) {
+    if (ethers.isAddress(name)) {
       return name
     }
 
@@ -419,7 +464,7 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
     return provider.resolveName(name)
   }
 
-  async lookupAddress(address: string | Promise<string>) {
+  async lookupAddress(address: string) {
     if (!(await this.supportsENS())) {
       return null
     }
@@ -443,9 +488,9 @@ export class SequenceProvider extends ethers.providers.BaseProvider implements I
   }
 }
 
-function normalizeChainId(chainId: string | number | bigint | { chainId: string }): number {
+function normalizeChainId(chainId: ethers.BigNumberish | { chainId: string }): number {
   if (typeof chainId === 'object') return normalizeChainId(chainId.chainId)
-  return ethers.BigNumber.from(chainId).toNumber()
+  return Number(chainId)
 }
 
 /**
@@ -462,10 +507,11 @@ export class SingleNetworkSequenceProvider extends SequenceProvider {
 
   constructor(
     client: SequenceClient,
-    providerFor: (networkId: number) => ethers.providers.JsonRpcProvider,
-    public readonly chainId: ChainIdLike
+    providerFor: (networkId: number) => ethers.JsonRpcProvider,
+    public readonly chainId: ChainIdLike,
+    options?: ethers.AbstractProviderOptions
   ) {
-    super(client, providerFor)
+    super(client, providerFor, undefined, options)
   }
 
   private _useChainId(chainId?: ChainIdLike): number {
@@ -486,15 +532,15 @@ export class SingleNetworkSequenceProvider extends SequenceProvider {
     return super.toChainId(this.chainId)
   }
 
-  async getNetwork(): Promise<NetworkConfig> {
+  async getNetwork(): Promise<ethers.Network> {
     const networks = await this.client.getNetworks()
-    const res = findNetworkConfig(networks, this.chainId)
+    const found = findNetworkConfig(networks, this.chainId)
 
-    if (!res) {
+    if (!found) {
       throw new Error(`Unsupported network ${this.chainId}`)
     }
 
-    return res
+    return new ethers.Network(found.name, found.chainId)
   }
 
   /**

package/src/signer.ts

@@ -8,7 +8,7 @@ import { resolveArrayProperties } from './utils'
 import { WalletUtils } from './utils/index'
 import { OptionalChainIdLike, OptionalEIP6492 } from './types'
 
-export interface ISequenceSigner extends ethers.Signer {
+export interface ISequenceSigner extends Omit<ethers.Signer, 'connect'> {
   getProvider(): SequenceProvider
   getProvider(chainId: ChainIdLike): SingleNetworkSequenceProvider
   getProvider(chainId?: ChainIdLike): SequenceProvider | SingleNetworkSequenceProvider
@@ -20,6 +20,8 @@ export interface ISequenceSigner extends ethers.Signer {
   getWalletConfig(chainId?: ChainIdLike): Promise<commons.config.Config>
   getNetworks(): Promise<NetworkConfig[]>
 
+  connect: (provider: SequenceProvider) => SequenceSigner
+
   signMessage(message: ethers.BytesLike, options?: OptionalChainIdLike & OptionalEIP6492): Promise<string>
 
   signTypedData(
@@ -33,9 +35,7 @@ export interface ISequenceSigner extends ethers.Signer {
   // the signer, and finally sends it to the relayer for submission to an Ethereum network.
   // It supports any kind of transaction, including regular ethers transactions, and Sequence transactions.
   sendTransaction(
-    transaction:
-      | ethers.utils.Deferrable<ethers.providers.TransactionRequest>[]
-      | ethers.utils.Deferrable<ethers.providers.TransactionRequest>,
+    transaction: ethers.TransactionRequest[] | ethers.TransactionRequest,
     options?: OptionalChainIdLike
   ): Promise<commons.transaction.TransactionResponse>
 
@@ -45,7 +45,6 @@ export interface ISequenceSigner extends ethers.Signer {
 export class SequenceSigner implements ISequenceSigner {
   private readonly singleNetworkSigners: { [chainId: number]: SingleNetworkSequenceSigner } = {}
 
-  readonly _isSigner: boolean = true
   readonly _isSequenceSigner: boolean = true
 
   get utils(): WalletUtils {
@@ -63,7 +62,7 @@ export class SequenceSigner implements ISequenceSigner {
 
   // This method shouldn't be used directly
   // it exists to maintain compatibility with ethers.Signer
-  connect(provider: ethers.providers.Provider): SequenceSigner {
+  connect(provider: ethers.Provider): SequenceSigner {
     if (!SequenceProvider.is(provider)) {
       throw new Error('SequenceSigner can only be connected to a SequenceProvider')
     }
@@ -124,25 +123,28 @@ export class SequenceSigner implements ISequenceSigner {
     return this.provider.getProvider(chainId)
   }
 
-  async sendTransaction(
-    transaction:
-      | ethers.utils.Deferrable<ethers.providers.TransactionRequest>[]
-      | ethers.utils.Deferrable<ethers.providers.TransactionRequest>,
-    options?: OptionalChainIdLike
-  ) {
+  async sendTransaction(transaction: ethers.TransactionRequest[] | ethers.TransactionRequest, options?: OptionalChainIdLike) {
     const chainId = this.useChainId(options?.chainId)
     const resolved = await resolveArrayProperties(transaction)
     const txHash = await this.client.sendTransaction(resolved, { chainId })
     const provider = this.getProvider(chainId)
 
     try {
-      return (await ethers.utils.poll(
-        async () => {
+      const result = await new Promise<ethers.TransactionResponse>(resolve => {
+        const check = async () => {
           const tx = await provider.getTransaction(txHash)
-          return tx ? provider._wrapTransaction(tx, txHash) : undefined
-        },
-        { onceBlock: provider }
-      )) as ethers.providers.TransactionResponse
+
+          if (tx !== null) {
+            return resolve(tx)
+          }
+
+          await provider.once('block', check)
+        }
+
+        check()
+      })
+
+      return result
     } catch (err) {
       err.transactionHash = txHash
       throw err
@@ -158,35 +160,24 @@ export class SequenceSigner implements ISequenceSigner {
     return this.client.getNetworks()
   }
 
-  async getBalance(blockTag?: ethers.providers.BlockTag | undefined, optionals?: OptionalChainIdLike): Promise<ethers.BigNumber> {
+  async getBalance(blockTag?: ethers.BlockTag | undefined, optionals?: OptionalChainIdLike): Promise<bigint> {
     const provider = this.getProvider(optionals?.chainId)
     return provider.getBalance(this.getAddress(), blockTag)
   }
 
-  async estimateGas(
-    transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>,
-    optionals?: OptionalChainIdLike
-  ): Promise<ethers.BigNumber> {
+  async estimateGas(transaction: ethers.TransactionRequest, optionals?: OptionalChainIdLike): Promise<bigint> {
     return this.getProvider(optionals?.chainId).estimateGas(transaction)
   }
 
-  async call(
-    transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>,
-    blockTag?: ethers.providers.BlockTag | undefined,
-    optionals?: OptionalChainIdLike
-  ): Promise<string> {
-    return this.getProvider(optionals?.chainId).call(transaction, blockTag)
+  async call(transaction: ethers.TransactionRequest, optionals?: OptionalChainIdLike): Promise<string> {
+    return this.getProvider(optionals?.chainId).call(transaction)
   }
 
   getChainId(): Promise<number> {
     return Promise.resolve(this.client.getChainId())
   }
 
-  async getGasPrice(optionals?: OptionalChainIdLike): Promise<ethers.BigNumber> {
-    return this.getProvider(optionals?.chainId).getGasPrice()
-  }
-
-  async getFeeData(optionals?: OptionalChainIdLike): Promise<ethers.providers.FeeData> {
+  async getFeeData(optionals?: OptionalChainIdLike): Promise<ethers.FeeData> {
     return this.getProvider(optionals?.chainId).getFeeData()
   }
 
@@ -194,7 +185,7 @@ export class SequenceSigner implements ISequenceSigner {
     const res = await this.provider.resolveName(name)
 
     // For some reason ethers.Signer expects this to return `string`
-    // but ethers.providers.Provider expects this to return `string | null`.
+    // but ethers.Provider expects this to return `string | null`.
     // The signer doesn't have any other source of information, so we'll
     // fail if the provider doesn't return a result.
     if (res === null) {
@@ -208,25 +199,29 @@ export class SequenceSigner implements ISequenceSigner {
     // We always have a provider, so this is a noop
   }
 
-  populateTransaction(
-    _transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>
-  ): Promise<ethers.providers.TransactionRequest> {
+  getNonce(_blockTag?: ethers.BlockTag): Promise<number> {
+    throw new Error('SequenceSigner does not support getNonce')
+  }
+
+  populateCall(_transaction: ethers.TransactionRequest): Promise<ethers.TransactionLike<string>> {
+    throw new Error('SequenceSigner does not support populateCall')
+  }
+
+  populateTransaction(_transaction: ethers.TransactionRequest): Promise<ethers.TransactionLike<string>> {
     throw new Error('SequenceSigner does not support populateTransaction')
   }
 
-  checkTransaction(
-    _transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>
-  ): ethers.utils.Deferrable<ethers.providers.TransactionRequest> {
+  checkTransaction(_transaction: ethers.TransactionRequest): ethers.TransactionRequest {
     throw new Error('SequenceSigner does not support checkTransaction')
   }
 
-  getTransactionCount(_blockTag?: ethers.providers.BlockTag | undefined): Promise<number> {
+  getTransactionCount(_blockTag?: ethers.BlockTag): Promise<number> {
     // We could try returning the sequence nonce here
     // but we aren't sure how ethers will use this nonce
     throw new Error('SequenceSigner does not support getTransactionCount')
   }
 
-  signTransaction(_transaction: ethers.utils.Deferrable<commons.transaction.Transactionish>): Promise<string> {
+  signTransaction(_transaction: commons.transaction.Transactionish): Promise<string> {
     // We could implement signTransaction/sendTransaction here
     // but first we need a way of serializing these signed transactions
     // and it could lead to more trouble, because the dapp could try to send this transaction

package/src/transactions.ts

@@ -12,7 +12,7 @@ const PROHIBITED_FUNCTIONS = new Map(
     'updateImageHash(bytes32)',
     'updateImageHashAndIPFS(bytes32,bytes32)',
     'updateImplementation(address)'
-  ].map(signature => [ethers.utils.keccak256(ethers.utils.toUtf8Bytes(signature)).slice(0, 10), signature])
+  ].map(signature => [ethers.id(signature).slice(0, 10), signature])
 )
 
 export function validateTransactionRequest(wallet: string, transaction: commons.transaction.Transactionish) {
@@ -24,7 +24,7 @@ export function validateTransactionRequest(wallet: string, transaction: commons.
 function validateTransaction(wallet: string, transaction: commons.transaction.Transaction) {
   if (transaction.to.toLowerCase() === wallet.toLowerCase()) {
     if (transaction.data) {
-      const data = ethers.utils.arrayify(transaction.data)
+      const data = ethers.getBytes(transaction.data)
       if (data.length >= 4 && !isCreateContractCall(data)) {
         throw new Error('self calls are forbidden')
       }
@@ -36,7 +36,7 @@ function validateTransaction(wallet: string, transaction: commons.transaction.Tr
   }
 
   if (transaction.data) {
-    const data = ethers.utils.hexlify(transaction.data)
+    const data = ethers.hexlify(transaction.data)
     const selector = data.slice(0, 10)
     const signature = PROHIBITED_FUNCTIONS.get(selector)
     if (signature) {
@@ -47,7 +47,7 @@ function validateTransaction(wallet: string, transaction: commons.transaction.Tr
 }
 
 function isCreateContractCall(data: ethers.BytesLike): boolean {
-  const walletInterface = new ethers.utils.Interface(walletContracts.mainModule.abi)
+  const walletInterface = new ethers.Interface(walletContracts.mainModule.abi)
   try {
     walletInterface.decodeFunctionData('createContract', data)
     return true