@0xsequence/relayer 1.10.15 → 2.0.0

package/dist/0xsequence-relayer.cjs.dev.js

@@ -22,14 +22,14 @@ function _extends() {
   return _extends.apply(this, arguments);
 }
 
-const DEFAULT_GAS_LIMIT = ethers.ethers.BigNumber.from(800000);
+const DEFAULT_GAS_LIMIT = 800000n;
 const ProviderRelayerDefaults = {
   waitPollRate: 1000,
   deltaBlocksLog: 12,
   fromBlockLog: -1024
 };
 function isProviderRelayerOptions(obj) {
-  return obj.provider !== undefined && ethers.providers.Provider.isProvider(obj.provider);
+  return typeof obj === 'object' && obj.provider instanceof ethers.ethers.AbstractProvider;
 }
 class ProviderRelayer {
   constructor(options) {
@@ -47,7 +47,7 @@ class ProviderRelayer {
     var _this = this;
     return (await Promise.all(transactions.map(async function (tx) {
       // Respect gasLimit request of the transaction (as long as its not 0)
-      if (tx.gasLimit && !ethers.ethers.BigNumber.from(tx.gasLimit || 0).eq(ethers.ethers.constants.Zero)) {
+      if (tx.gasLimit && BigInt(tx.gasLimit || 0) !== 0n) {
         return tx.gasLimit;
       }
 
@@ -57,7 +57,7 @@ class ProviderRelayer {
       }
 
       // Fee can't be estimated for self-called if wallet hasn't been deployed
-      if (tx.to === wallet && (await _this.provider.getCode(wallet).then(code => ethers.ethers.utils.arrayify(code).length === 0))) {
+      if (tx.to === wallet && (await _this.provider.getCode(wallet).then(code => ethers.ethers.getBytes(code).length === 0))) {
         return DEFAULT_GAS_LIMIT;
       }
       if (!_this.provider) {
@@ -75,8 +75,8 @@ class ProviderRelayer {
     }))).map(gasLimit => ({
       executed: true,
       succeeded: true,
-      gasUsed: ethers.ethers.BigNumber.from(gasLimit).toNumber(),
-      gasLimit: ethers.ethers.BigNumber.from(gasLimit).toNumber()
+      gasUsed: Number(gasLimit),
+      gasLimit: Number(gasLimit)
     }));
   }
   async getNonce(address, space, blockTag) {
@@ -147,15 +147,23 @@ class ProviderRelayer {
         const txs = await Promise.all(logs.map(l => retry(() => _this2.provider.getTransactionReceipt(l.transactionHash), `unable to get receipt for transaction ${l.transactionHash}`)));
 
         // Find a transaction with a TxExecuted log
-        const found = txs.find(tx => tx.logs.find(l => l.topics.length === 0 && l.data.replace('0x', '') === normalMetaTxnId || l.topics.length === 1 &&
+        const found = txs.find(tx => tx == null ? void 0 : tx.logs.find(l => l.topics.length === 0 && l.data.replace('0x', '') === normalMetaTxnId || l.topics.length === 1 &&
         // TxFailed event topic
         l.topics[0] === '0x3dbd1590ea96dd3253a91f24e64e3a502e1225d602a5731357bc12643070ccd7' && l.data.length >= 64 && l.data.replace('0x', '').startsWith(normalMetaTxnId)));
 
         // If found return that
         if (found) {
-          return _extends({
-            receipt: found
-          }, await retry(() => _this2.provider.getTransaction(found.transactionHash), `unable to get transaction ${found.transactionHash}`));
+          const response = await retry(() => _this2.provider.getTransaction(found.hash), `unable to get transaction ${found.hash}`);
+          if (!response) {
+            throw new Error(`Transaction response not found for  ${metaTxnId}`);
+          }
+
+          // NOTE: we have to do this, because ethers-v6 uses private fields
+          // and we can't just extend the class and override the method, so
+          // we just modify the response object directly by adding the receipt to it.
+          const out = response;
+          out.receipt = found;
+          return out;
         }
 
         // Otherwise wait and try again
@@ -177,18 +185,18 @@ class ProviderRelayer {
 }
 
 function isLocalRelayerOptions(obj) {
-  return obj.signer !== undefined && ethers.Signer.isSigner(obj.signer);
+  return typeof obj === 'object' && obj.signer instanceof ethers.ethers.AbstractSigner;
 }
 class LocalRelayer extends ProviderRelayer {
   constructor(options) {
-    super(ethers.Signer.isSigner(options) ? {
+    super(options instanceof ethers.ethers.AbstractSigner ? {
       provider: options.provider
     } : _extends({}, options, {
       provider: options.signer.provider
     }));
     this.signer = void 0;
     this.txnOptions = void 0;
-    this.signer = ethers.Signer.isSigner(options) ? options : options.signer;
+    this.signer = options instanceof ethers.ethers.AbstractSigner ? options : options.signer;
     if (!this.signer.provider) throw new Error('Signer must have a provider');
   }
   async getFeeOptions(_address, ..._transactions) {
@@ -218,7 +226,7 @@ class LocalRelayer extends ProviderRelayer {
 
     // TODO: think about computing gas limit individually, summing together and passing across
     // NOTE: we expect that all txns have set their gasLimit ahead of time through proper estimation
-    // const gasLimit = signedTxs.transactions.reduce((sum, tx) => sum.add(tx.gasLimit), ethers.BigNumber.from(0))
+    // const gasLimit = signedTxs.transactions.reduce((sum, tx) => sum + tx.gasLimit, 0n)
     // txRequest.gasLimit = gasLimit
 
     const responsePromise = this.signer.sendTransaction(_extends({
@@ -966,7 +974,7 @@ var relayer_gen = /*#__PURE__*/Object.freeze({
 const FINAL_STATUSES = [ETHTxnStatus.DROPPED, ETHTxnStatus.SUCCEEDED, ETHTxnStatus.PARTIALLY_FAILED, ETHTxnStatus.FAILED];
 const FAILED_STATUSES = [ETHTxnStatus.DROPPED, ETHTxnStatus.PARTIALLY_FAILED, ETHTxnStatus.FAILED];
 function isRpcRelayerOptions(obj) {
-  return obj.url !== undefined && typeof obj.url === 'string' && obj.provider !== undefined && ethers.ethers.providers.Provider.isProvider(obj.provider);
+  return obj.url !== undefined && typeof obj.url === 'string' && obj.provider !== undefined && obj.provider instanceof ethers.ethers.AbstractProvider;
 }
 const fetch = globalThis.fetch;
 
@@ -996,15 +1004,17 @@ class RpcRelayer {
       return fetch(input, init);
     };
     this.service = new Relayer(options.url, this._fetch);
-    if (ethers.ethers.providers.Provider.isProvider(options.provider)) {
+    if (options.provider instanceof ethers.ethers.AbstractProvider) {
       this.provider = options.provider;
     } else {
       const {
         jwtAuth,
         projectAccessKey
       } = this.options;
-      const providerConnectionInfo = utils.getEthersConnectionInfo(options.provider.url, projectAccessKey, jwtAuth);
-      this.provider = new ethers.ethers.providers.StaticJsonRpcProvider(providerConnectionInfo);
+      const fetchRequest = utils.getFetchRequest(options.provider.url, projectAccessKey, jwtAuth);
+      this.provider = new ethers.ethers.JsonRpcProvider(fetchRequest, undefined, {
+        staticNetwork: true
+      });
     }
   }
   async waitReceipt(metaTxnId, delay = 1000, maxFails = 5, isCancelled) {
@@ -1038,7 +1048,7 @@ class RpcRelayer {
     throw new Error(`Cancelled waiting for transaction receipt ${metaTxnId}`);
   }
   async simulate(wallet, ...transactions) {
-    const coder = ethers.ethers.utils.defaultAbiCoder;
+    const coder = ethers.ethers.AbiCoder.defaultAbiCoder();
     const encoded = coder.encode([core.commons.transaction.MetaTransactionsType], [core.commons.transaction.sequenceTxAbiEncode(transactions)]);
     return (await this.service.simulate({
       wallet,
@@ -1092,7 +1102,7 @@ class RpcRelayer {
     } = await this.service.feeOptions({
       wallet: entrypoint,
       to: entrypoint,
-      data: ethers.ethers.utils.hexlify(data),
+      data: ethers.ethers.hexlify(data),
       simulate: options == null ? void 0 : options.simulate
     });
     return {
@@ -1111,12 +1121,12 @@ class RpcRelayer {
   }
   async getNonce(address, space) {
     utils.logger.info(`[rpc-relayer/getNonce] get nonce for wallet ${address} space: ${space}`);
-    const encodedNonce = space !== undefined ? ethers.ethers.BigNumber.from(space).toHexString() : undefined;
+    const encodedNonce = space !== undefined ? utils.toHexString(BigInt(space)) : undefined;
     const resp = await this.service.getMetaTxnNonce({
       walletContractAddress: address,
       space: encodedNonce
     });
-    const nonce = ethers.ethers.BigNumber.from(resp.nonce);
+    const nonce = BigInt(resp.nonce);
     const [decodedSpace, decodedNonce] = core.commons.transaction.decodeNonce(nonce);
     utils.logger.info(`[rpc-relayer/getNonce] got next nonce for wallet ${address} ${decodedNonce} space: ${decodedSpace}`);
     return nonce;
@@ -1169,6 +1179,10 @@ class RpcRelayer {
         return _this.provider.waitForTransaction(transactionHash, confirmations);
       };
       response.wait = wait;
+
+      // NOTE: we just ignore these errors which come from the private fields
+      // of ethers-v6 .. but, we should probably rework this instead..
+      // @ts-ignore
       return response;
     }
   }
@@ -1185,9 +1199,13 @@ class RpcRelayer {
       throw new MetaTransactionResponseException(receipt);
     }
     const txReceipt = JSON.parse(receipt.txnReceipt);
+
+    // NOTE: we just ignore these errors which come from the private fields
+    // of ethers-v6 .. but, we should probably rework this instead..
+    // @ts-ignore
     return {
       blockHash: txReceipt.blockHash,
-      blockNumber: ethers.ethers.BigNumber.from(txReceipt.blockNumber).toNumber(),
+      blockNumber: Number(txReceipt.blockNumber),
       confirmations: 1,
       from: typeof metaTxnId === 'string' ? undefined : metaTxnId.intent.wallet,
       hash: txReceipt.transactionHash,

package/dist/0xsequence-relayer.cjs.prod.js

@@ -22,14 +22,14 @@ function _extends() {
   return _extends.apply(this, arguments);
 }
 
-const DEFAULT_GAS_LIMIT = ethers.ethers.BigNumber.from(800000);
+const DEFAULT_GAS_LIMIT = 800000n;
 const ProviderRelayerDefaults = {
   waitPollRate: 1000,
   deltaBlocksLog: 12,
   fromBlockLog: -1024
 };
 function isProviderRelayerOptions(obj) {
-  return obj.provider !== undefined && ethers.providers.Provider.isProvider(obj.provider);
+  return typeof obj === 'object' && obj.provider instanceof ethers.ethers.AbstractProvider;
 }
 class ProviderRelayer {
   constructor(options) {
@@ -47,7 +47,7 @@ class ProviderRelayer {
     var _this = this;
     return (await Promise.all(transactions.map(async function (tx) {
       // Respect gasLimit request of the transaction (as long as its not 0)
-      if (tx.gasLimit && !ethers.ethers.BigNumber.from(tx.gasLimit || 0).eq(ethers.ethers.constants.Zero)) {
+      if (tx.gasLimit && BigInt(tx.gasLimit || 0) !== 0n) {
         return tx.gasLimit;
       }
 
@@ -57,7 +57,7 @@ class ProviderRelayer {
       }
 
       // Fee can't be estimated for self-called if wallet hasn't been deployed
-      if (tx.to === wallet && (await _this.provider.getCode(wallet).then(code => ethers.ethers.utils.arrayify(code).length === 0))) {
+      if (tx.to === wallet && (await _this.provider.getCode(wallet).then(code => ethers.ethers.getBytes(code).length === 0))) {
         return DEFAULT_GAS_LIMIT;
       }
       if (!_this.provider) {
@@ -75,8 +75,8 @@ class ProviderRelayer {
     }))).map(gasLimit => ({
       executed: true,
       succeeded: true,
-      gasUsed: ethers.ethers.BigNumber.from(gasLimit).toNumber(),
-      gasLimit: ethers.ethers.BigNumber.from(gasLimit).toNumber()
+      gasUsed: Number(gasLimit),
+      gasLimit: Number(gasLimit)
     }));
   }
   async getNonce(address, space, blockTag) {
@@ -147,15 +147,23 @@ class ProviderRelayer {
         const txs = await Promise.all(logs.map(l => retry(() => _this2.provider.getTransactionReceipt(l.transactionHash), `unable to get receipt for transaction ${l.transactionHash}`)));
 
         // Find a transaction with a TxExecuted log
-        const found = txs.find(tx => tx.logs.find(l => l.topics.length === 0 && l.data.replace('0x', '') === normalMetaTxnId || l.topics.length === 1 &&
+        const found = txs.find(tx => tx == null ? void 0 : tx.logs.find(l => l.topics.length === 0 && l.data.replace('0x', '') === normalMetaTxnId || l.topics.length === 1 &&
         // TxFailed event topic
         l.topics[0] === '0x3dbd1590ea96dd3253a91f24e64e3a502e1225d602a5731357bc12643070ccd7' && l.data.length >= 64 && l.data.replace('0x', '').startsWith(normalMetaTxnId)));
 
         // If found return that
         if (found) {
-          return _extends({
-            receipt: found
-          }, await retry(() => _this2.provider.getTransaction(found.transactionHash), `unable to get transaction ${found.transactionHash}`));
+          const response = await retry(() => _this2.provider.getTransaction(found.hash), `unable to get transaction ${found.hash}`);
+          if (!response) {
+            throw new Error(`Transaction response not found for  ${metaTxnId}`);
+          }
+
+          // NOTE: we have to do this, because ethers-v6 uses private fields
+          // and we can't just extend the class and override the method, so
+          // we just modify the response object directly by adding the receipt to it.
+          const out = response;
+          out.receipt = found;
+          return out;
         }
 
         // Otherwise wait and try again
@@ -177,18 +185,18 @@ class ProviderRelayer {
 }
 
 function isLocalRelayerOptions(obj) {
-  return obj.signer !== undefined && ethers.Signer.isSigner(obj.signer);
+  return typeof obj === 'object' && obj.signer instanceof ethers.ethers.AbstractSigner;
 }
 class LocalRelayer extends ProviderRelayer {
   constructor(options) {
-    super(ethers.Signer.isSigner(options) ? {
+    super(options instanceof ethers.ethers.AbstractSigner ? {
       provider: options.provider
     } : _extends({}, options, {
       provider: options.signer.provider
     }));
     this.signer = void 0;
     this.txnOptions = void 0;
-    this.signer = ethers.Signer.isSigner(options) ? options : options.signer;
+    this.signer = options instanceof ethers.ethers.AbstractSigner ? options : options.signer;
     if (!this.signer.provider) throw new Error('Signer must have a provider');
   }
   async getFeeOptions(_address, ..._transactions) {
@@ -218,7 +226,7 @@ class LocalRelayer extends ProviderRelayer {
 
     // TODO: think about computing gas limit individually, summing together and passing across
     // NOTE: we expect that all txns have set their gasLimit ahead of time through proper estimation
-    // const gasLimit = signedTxs.transactions.reduce((sum, tx) => sum.add(tx.gasLimit), ethers.BigNumber.from(0))
+    // const gasLimit = signedTxs.transactions.reduce((sum, tx) => sum + tx.gasLimit, 0n)
     // txRequest.gasLimit = gasLimit
 
     const responsePromise = this.signer.sendTransaction(_extends({
@@ -966,7 +974,7 @@ var relayer_gen = /*#__PURE__*/Object.freeze({
 const FINAL_STATUSES = [ETHTxnStatus.DROPPED, ETHTxnStatus.SUCCEEDED, ETHTxnStatus.PARTIALLY_FAILED, ETHTxnStatus.FAILED];
 const FAILED_STATUSES = [ETHTxnStatus.DROPPED, ETHTxnStatus.PARTIALLY_FAILED, ETHTxnStatus.FAILED];
 function isRpcRelayerOptions(obj) {
-  return obj.url !== undefined && typeof obj.url === 'string' && obj.provider !== undefined && ethers.ethers.providers.Provider.isProvider(obj.provider);
+  return obj.url !== undefined && typeof obj.url === 'string' && obj.provider !== undefined && obj.provider instanceof ethers.ethers.AbstractProvider;
 }
 const fetch = globalThis.fetch;
 
@@ -996,15 +1004,17 @@ class RpcRelayer {
       return fetch(input, init);
     };
     this.service = new Relayer(options.url, this._fetch);
-    if (ethers.ethers.providers.Provider.isProvider(options.provider)) {
+    if (options.provider instanceof ethers.ethers.AbstractProvider) {
       this.provider = options.provider;
     } else {
       const {
         jwtAuth,
         projectAccessKey
       } = this.options;
-      const providerConnectionInfo = utils.getEthersConnectionInfo(options.provider.url, projectAccessKey, jwtAuth);
-      this.provider = new ethers.ethers.providers.StaticJsonRpcProvider(providerConnectionInfo);
+      const fetchRequest = utils.getFetchRequest(options.provider.url, projectAccessKey, jwtAuth);
+      this.provider = new ethers.ethers.JsonRpcProvider(fetchRequest, undefined, {
+        staticNetwork: true
+      });
     }
   }
   async waitReceipt(metaTxnId, delay = 1000, maxFails = 5, isCancelled) {
@@ -1038,7 +1048,7 @@ class RpcRelayer {
     throw new Error(`Cancelled waiting for transaction receipt ${metaTxnId}`);
   }
   async simulate(wallet, ...transactions) {
-    const coder = ethers.ethers.utils.defaultAbiCoder;
+    const coder = ethers.ethers.AbiCoder.defaultAbiCoder();
     const encoded = coder.encode([core.commons.transaction.MetaTransactionsType], [core.commons.transaction.sequenceTxAbiEncode(transactions)]);
     return (await this.service.simulate({
       wallet,
@@ -1092,7 +1102,7 @@ class RpcRelayer {
     } = await this.service.feeOptions({
       wallet: entrypoint,
       to: entrypoint,
-      data: ethers.ethers.utils.hexlify(data),
+      data: ethers.ethers.hexlify(data),
       simulate: options == null ? void 0 : options.simulate
     });
     return {
@@ -1111,12 +1121,12 @@ class RpcRelayer {
   }
   async getNonce(address, space) {
     utils.logger.info(`[rpc-relayer/getNonce] get nonce for wallet ${address} space: ${space}`);
-    const encodedNonce = space !== undefined ? ethers.ethers.BigNumber.from(space).toHexString() : undefined;
+    const encodedNonce = space !== undefined ? utils.toHexString(BigInt(space)) : undefined;
     const resp = await this.service.getMetaTxnNonce({
       walletContractAddress: address,
       space: encodedNonce
     });
-    const nonce = ethers.ethers.BigNumber.from(resp.nonce);
+    const nonce = BigInt(resp.nonce);
     const [decodedSpace, decodedNonce] = core.commons.transaction.decodeNonce(nonce);
     utils.logger.info(`[rpc-relayer/getNonce] got next nonce for wallet ${address} ${decodedNonce} space: ${decodedSpace}`);
     return nonce;
@@ -1169,6 +1179,10 @@ class RpcRelayer {
         return _this.provider.waitForTransaction(transactionHash, confirmations);
       };
       response.wait = wait;
+
+      // NOTE: we just ignore these errors which come from the private fields
+      // of ethers-v6 .. but, we should probably rework this instead..
+      // @ts-ignore
       return response;
     }
   }
@@ -1185,9 +1199,13 @@ class RpcRelayer {
       throw new MetaTransactionResponseException(receipt);
     }
     const txReceipt = JSON.parse(receipt.txnReceipt);
+
+    // NOTE: we just ignore these errors which come from the private fields
+    // of ethers-v6 .. but, we should probably rework this instead..
+    // @ts-ignore
     return {
       blockHash: txReceipt.blockHash,
-      blockNumber: ethers.ethers.BigNumber.from(txReceipt.blockNumber).toNumber(),
+      blockNumber: Number(txReceipt.blockNumber),
       confirmations: 1,
       from: typeof metaTxnId === 'string' ? undefined : metaTxnId.intent.wallet,
       hash: txReceipt.transactionHash,

package/dist/0xsequence-relayer.esm.js

@@ -1,5 +1,5 @@
-import { ethers, providers, Signer } from 'ethers';
-import { logger, getEthersConnectionInfo } from '@0xsequence/utils';
+import { ethers } from 'ethers';
+import { logger, getFetchRequest, toHexString } from '@0xsequence/utils';
 import { walletContracts } from '@0xsequence/abi';
 import { commons } from '@0xsequence/core';
 
@@ -18,14 +18,14 @@ function _extends() {
   return _extends.apply(this, arguments);
 }
 
-const DEFAULT_GAS_LIMIT = ethers.BigNumber.from(800000);
+const DEFAULT_GAS_LIMIT = 800000n;
 const ProviderRelayerDefaults = {
   waitPollRate: 1000,
   deltaBlocksLog: 12,
   fromBlockLog: -1024
 };
 function isProviderRelayerOptions(obj) {
-  return obj.provider !== undefined && providers.Provider.isProvider(obj.provider);
+  return typeof obj === 'object' && obj.provider instanceof ethers.AbstractProvider;
 }
 class ProviderRelayer {
   constructor(options) {
@@ -43,7 +43,7 @@ class ProviderRelayer {
     var _this = this;
     return (await Promise.all(transactions.map(async function (tx) {
       // Respect gasLimit request of the transaction (as long as its not 0)
-      if (tx.gasLimit && !ethers.BigNumber.from(tx.gasLimit || 0).eq(ethers.constants.Zero)) {
+      if (tx.gasLimit && BigInt(tx.gasLimit || 0) !== 0n) {
         return tx.gasLimit;
       }
 
@@ -53,7 +53,7 @@ class ProviderRelayer {
       }
 
       // Fee can't be estimated for self-called if wallet hasn't been deployed
-      if (tx.to === wallet && (await _this.provider.getCode(wallet).then(code => ethers.utils.arrayify(code).length === 0))) {
+      if (tx.to === wallet && (await _this.provider.getCode(wallet).then(code => ethers.getBytes(code).length === 0))) {
         return DEFAULT_GAS_LIMIT;
       }
       if (!_this.provider) {
@@ -71,8 +71,8 @@ class ProviderRelayer {
     }))).map(gasLimit => ({
       executed: true,
       succeeded: true,
-      gasUsed: ethers.BigNumber.from(gasLimit).toNumber(),
-      gasLimit: ethers.BigNumber.from(gasLimit).toNumber()
+      gasUsed: Number(gasLimit),
+      gasLimit: Number(gasLimit)
     }));
   }
   async getNonce(address, space, blockTag) {
@@ -143,15 +143,23 @@ class ProviderRelayer {
         const txs = await Promise.all(logs.map(l => retry(() => _this2.provider.getTransactionReceipt(l.transactionHash), `unable to get receipt for transaction ${l.transactionHash}`)));
 
         // Find a transaction with a TxExecuted log
-        const found = txs.find(tx => tx.logs.find(l => l.topics.length === 0 && l.data.replace('0x', '') === normalMetaTxnId || l.topics.length === 1 &&
+        const found = txs.find(tx => tx == null ? void 0 : tx.logs.find(l => l.topics.length === 0 && l.data.replace('0x', '') === normalMetaTxnId || l.topics.length === 1 &&
         // TxFailed event topic
         l.topics[0] === '0x3dbd1590ea96dd3253a91f24e64e3a502e1225d602a5731357bc12643070ccd7' && l.data.length >= 64 && l.data.replace('0x', '').startsWith(normalMetaTxnId)));
 
         // If found return that
         if (found) {
-          return _extends({
-            receipt: found
-          }, await retry(() => _this2.provider.getTransaction(found.transactionHash), `unable to get transaction ${found.transactionHash}`));
+          const response = await retry(() => _this2.provider.getTransaction(found.hash), `unable to get transaction ${found.hash}`);
+          if (!response) {
+            throw new Error(`Transaction response not found for  ${metaTxnId}`);
+          }
+
+          // NOTE: we have to do this, because ethers-v6 uses private fields
+          // and we can't just extend the class and override the method, so
+          // we just modify the response object directly by adding the receipt to it.
+          const out = response;
+          out.receipt = found;
+          return out;
         }
 
         // Otherwise wait and try again
@@ -173,18 +181,18 @@ class ProviderRelayer {
 }
 
 function isLocalRelayerOptions(obj) {
-  return obj.signer !== undefined && Signer.isSigner(obj.signer);
+  return typeof obj === 'object' && obj.signer instanceof ethers.AbstractSigner;
 }
 class LocalRelayer extends ProviderRelayer {
   constructor(options) {
-    super(Signer.isSigner(options) ? {
+    super(options instanceof ethers.AbstractSigner ? {
       provider: options.provider
     } : _extends({}, options, {
       provider: options.signer.provider
     }));
     this.signer = void 0;
     this.txnOptions = void 0;
-    this.signer = Signer.isSigner(options) ? options : options.signer;
+    this.signer = options instanceof ethers.AbstractSigner ? options : options.signer;
     if (!this.signer.provider) throw new Error('Signer must have a provider');
   }
   async getFeeOptions(_address, ..._transactions) {
@@ -214,7 +222,7 @@ class LocalRelayer extends ProviderRelayer {
 
     // TODO: think about computing gas limit individually, summing together and passing across
     // NOTE: we expect that all txns have set their gasLimit ahead of time through proper estimation
-    // const gasLimit = signedTxs.transactions.reduce((sum, tx) => sum.add(tx.gasLimit), ethers.BigNumber.from(0))
+    // const gasLimit = signedTxs.transactions.reduce((sum, tx) => sum + tx.gasLimit, 0n)
     // txRequest.gasLimit = gasLimit
 
     const responsePromise = this.signer.sendTransaction(_extends({
@@ -962,7 +970,7 @@ var relayer_gen = /*#__PURE__*/Object.freeze({
 const FINAL_STATUSES = [ETHTxnStatus.DROPPED, ETHTxnStatus.SUCCEEDED, ETHTxnStatus.PARTIALLY_FAILED, ETHTxnStatus.FAILED];
 const FAILED_STATUSES = [ETHTxnStatus.DROPPED, ETHTxnStatus.PARTIALLY_FAILED, ETHTxnStatus.FAILED];
 function isRpcRelayerOptions(obj) {
-  return obj.url !== undefined && typeof obj.url === 'string' && obj.provider !== undefined && ethers.providers.Provider.isProvider(obj.provider);
+  return obj.url !== undefined && typeof obj.url === 'string' && obj.provider !== undefined && obj.provider instanceof ethers.AbstractProvider;
 }
 const fetch = globalThis.fetch;
 
@@ -992,15 +1000,17 @@ class RpcRelayer {
       return fetch(input, init);
     };
     this.service = new Relayer(options.url, this._fetch);
-    if (ethers.providers.Provider.isProvider(options.provider)) {
+    if (options.provider instanceof ethers.AbstractProvider) {
       this.provider = options.provider;
     } else {
       const {
         jwtAuth,
         projectAccessKey
       } = this.options;
-      const providerConnectionInfo = getEthersConnectionInfo(options.provider.url, projectAccessKey, jwtAuth);
-      this.provider = new ethers.providers.StaticJsonRpcProvider(providerConnectionInfo);
+      const fetchRequest = getFetchRequest(options.provider.url, projectAccessKey, jwtAuth);
+      this.provider = new ethers.JsonRpcProvider(fetchRequest, undefined, {
+        staticNetwork: true
+      });
     }
   }
   async waitReceipt(metaTxnId, delay = 1000, maxFails = 5, isCancelled) {
@@ -1034,7 +1044,7 @@ class RpcRelayer {
     throw new Error(`Cancelled waiting for transaction receipt ${metaTxnId}`);
   }
   async simulate(wallet, ...transactions) {
-    const coder = ethers.utils.defaultAbiCoder;
+    const coder = ethers.AbiCoder.defaultAbiCoder();
     const encoded = coder.encode([commons.transaction.MetaTransactionsType], [commons.transaction.sequenceTxAbiEncode(transactions)]);
     return (await this.service.simulate({
       wallet,
@@ -1088,7 +1098,7 @@ class RpcRelayer {
     } = await this.service.feeOptions({
       wallet: entrypoint,
       to: entrypoint,
-      data: ethers.utils.hexlify(data),
+      data: ethers.hexlify(data),
       simulate: options == null ? void 0 : options.simulate
     });
     return {
@@ -1107,12 +1117,12 @@ class RpcRelayer {
   }
   async getNonce(address, space) {
     logger.info(`[rpc-relayer/getNonce] get nonce for wallet ${address} space: ${space}`);
-    const encodedNonce = space !== undefined ? ethers.BigNumber.from(space).toHexString() : undefined;
+    const encodedNonce = space !== undefined ? toHexString(BigInt(space)) : undefined;
     const resp = await this.service.getMetaTxnNonce({
       walletContractAddress: address,
       space: encodedNonce
     });
-    const nonce = ethers.BigNumber.from(resp.nonce);
+    const nonce = BigInt(resp.nonce);
     const [decodedSpace, decodedNonce] = commons.transaction.decodeNonce(nonce);
     logger.info(`[rpc-relayer/getNonce] got next nonce for wallet ${address} ${decodedNonce} space: ${decodedSpace}`);
     return nonce;
@@ -1165,6 +1175,10 @@ class RpcRelayer {
         return _this.provider.waitForTransaction(transactionHash, confirmations);
       };
       response.wait = wait;
+
+      // NOTE: we just ignore these errors which come from the private fields
+      // of ethers-v6 .. but, we should probably rework this instead..
+      // @ts-ignore
       return response;
     }
   }
@@ -1181,9 +1195,13 @@ class RpcRelayer {
       throw new MetaTransactionResponseException(receipt);
     }
     const txReceipt = JSON.parse(receipt.txnReceipt);
+
+    // NOTE: we just ignore these errors which come from the private fields
+    // of ethers-v6 .. but, we should probably rework this instead..
+    // @ts-ignore
     return {
       blockHash: txReceipt.blockHash,
-      blockNumber: ethers.BigNumber.from(txReceipt.blockNumber).toNumber(),
+      blockNumber: Number(txReceipt.blockNumber),
       confirmations: 1,
       from: typeof metaTxnId === 'string' ? undefined : metaTxnId.intent.wallet,
       hash: txReceipt.transactionHash,

package/dist/declarations/src/index.d.ts

@@ -1,4 +1,4 @@
-import { ethers, providers } from 'ethers';
+import { ethers } from 'ethers';
 import { proto } from "./rpc-relayer/index.js";
 import { commons } from '@0xsequence/core';
 export interface Relayer {
@@ -7,14 +7,14 @@ export interface Relayer {
         options: FeeOption[];
         quote?: FeeQuote;
     }>;
-    getFeeOptionsRaw(entrypoint: string, data: ethers.utils.BytesLike, options?: {
+    getFeeOptionsRaw(entrypoint: string, data: ethers.BytesLike, options?: {
         simulate?: boolean;
     }): Promise<{
         options: FeeOption[];
         quote?: FeeQuote;
     }>;
     gasRefundOptions(address: string, ...transactions: commons.transaction.Transaction[]): Promise<FeeOption[]>;
-    getNonce(address: string, space?: ethers.BigNumberish, blockTag?: providers.BlockTag): Promise<ethers.BigNumberish>;
+    getNonce(address: string, space?: ethers.BigNumberish, blockTag?: ethers.BlockTag): Promise<ethers.BigNumberish>;
     relay(signedTxs: commons.transaction.IntendedTransactionBundle, quote?: FeeQuote, waitForReceipt?: boolean): Promise<commons.transaction.TransactionResponse>;
     wait(metaTxnId: string | commons.transaction.SignedTransactionBundle, timeout?: number, delay?: number, maxFails?: number): Promise<commons.transaction.TransactionResponse>;
 }

package/dist/declarations/src/local-relayer.d.ts

@@ -1,24 +1,24 @@
-import { Signer as AbstractSigner, providers, BytesLike } from 'ethers';
+import { ethers } from 'ethers';
 import { FeeOption, FeeQuote, Relayer } from "./index.js";
 import { ProviderRelayer, ProviderRelayerOptions } from "./provider-relayer.js";
 import { commons } from '@0xsequence/core';
 export type LocalRelayerOptions = Omit<ProviderRelayerOptions, 'provider'> & {
-    signer: AbstractSigner;
+    signer: ethers.Signer;
 };
 export declare function isLocalRelayerOptions(obj: any): obj is LocalRelayerOptions;
 export declare class LocalRelayer extends ProviderRelayer implements Relayer {
     private signer;
     private txnOptions;
-    constructor(options: LocalRelayerOptions | AbstractSigner);
+    constructor(options: LocalRelayerOptions | ethers.AbstractSigner);
     getFeeOptions(_address: string, ..._transactions: commons.transaction.Transaction[]): Promise<{
         options: FeeOption[];
     }>;
-    getFeeOptionsRaw(_entrypoint: string, _data: BytesLike, _options?: {
+    getFeeOptionsRaw(_entrypoint: string, _data: ethers.BytesLike, _options?: {
         simulate?: boolean;
     }): Promise<{
         options: FeeOption[];
     }>;
     gasRefundOptions(address: string, ...transactions: commons.transaction.Transaction[]): Promise<FeeOption[]>;
-    setTransactionOptions(transactionRequest: providers.TransactionRequest): void;
-    relay(signedTxs: commons.transaction.IntendedTransactionBundle, quote?: FeeQuote, waitForReceipt?: boolean): Promise<commons.transaction.TransactionResponse<providers.TransactionReceipt>>;
+    setTransactionOptions(transactionRequest: ethers.TransactionRequest): void;
+    relay(signedTxs: commons.transaction.IntendedTransactionBundle, quote?: FeeQuote, waitForReceipt?: boolean): Promise<commons.transaction.TransactionResponse<ethers.TransactionReceipt>>;
 }

package/dist/declarations/src/provider-relayer.d.ts

@@ -1,9 +1,9 @@
-import { ethers, providers } from 'ethers';
+import { ethers } from 'ethers';
 import { FeeOption, FeeQuote, Relayer, SimulateResult } from "./index.js";
 import { Optionals } from '@0xsequence/utils';
 import { commons } from '@0xsequence/core';
 export interface ProviderRelayerOptions {
-    provider: providers.Provider;
+    provider: ethers.Provider;
     waitPollRate?: number;
     deltaBlocksLog?: number;
     fromBlockLog?: number;
@@ -11,7 +11,7 @@ export interface ProviderRelayerOptions {
 export declare const ProviderRelayerDefaults: Required<Optionals<ProviderRelayerOptions>>;
 export declare function isProviderRelayerOptions(obj: any): obj is ProviderRelayerOptions;
 export declare abstract class ProviderRelayer implements Relayer {
-    provider: providers.Provider;
+    provider: ethers.Provider;
     waitPollRate: number;
     deltaBlocksLog: number;
     fromBlockLog: number;
@@ -20,7 +20,7 @@ export declare abstract class ProviderRelayer implements Relayer {
         options: FeeOption[];
         quote?: FeeQuote;
     }>;
-    abstract getFeeOptionsRaw(entrypoint: string, data: ethers.utils.BytesLike, options?: {
+    abstract getFeeOptionsRaw(entrypoint: string, data: ethers.BytesLike, options?: {
         simulate?: boolean;
     }): Promise<{
         options: FeeOption[];
@@ -29,8 +29,8 @@ export declare abstract class ProviderRelayer implements Relayer {
     abstract gasRefundOptions(address: string, ...transactions: commons.transaction.Transaction[]): Promise<FeeOption[]>;
     abstract relay(signedTxs: commons.transaction.IntendedTransactionBundle, quote?: FeeQuote, waitForReceipt?: boolean): Promise<commons.transaction.TransactionResponse>;
     simulate(wallet: string, ...transactions: commons.transaction.Transaction[]): Promise<SimulateResult[]>;
-    getNonce(address: string, space?: ethers.BigNumberish, blockTag?: providers.BlockTag): Promise<ethers.BigNumberish>;
-    wait(metaTxnId: string | commons.transaction.SignedTransactionBundle, timeoutDuration?: number, delay?: number, maxFails?: number): Promise<providers.TransactionResponse & {
-        receipt: providers.TransactionReceipt;
+    getNonce(address: string, space?: ethers.BigNumberish, blockTag?: ethers.BlockTag): Promise<ethers.BigNumberish>;
+    wait(metaTxnId: string | commons.transaction.SignedTransactionBundle, timeoutDuration?: number, delay?: number, maxFails?: number): Promise<ethers.TransactionResponse & {
+        receipt: ethers.TransactionReceipt;
     }>;
 }

package/dist/declarations/src/rpc-relayer/index.d.ts

@@ -4,7 +4,7 @@ import * as proto from "./relayer.gen.js";
 import { commons } from '@0xsequence/core';
 export { proto };
 export interface RpcRelayerOptions {
-    provider: ethers.providers.Provider | {
+    provider: ethers.AbstractProvider | {
         url: string;
     };
     url: string;
@@ -15,7 +15,7 @@ export declare function isRpcRelayerOptions(obj: any): obj is RpcRelayerOptions;
 export declare class RpcRelayer implements Relayer {
     options: RpcRelayerOptions;
     private readonly service;
-    readonly provider: ethers.providers.Provider;
+    readonly provider: ethers.Provider;
     constructor(options: RpcRelayerOptions);
     _fetch: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
     waitReceipt(metaTxnId: string | commons.transaction.SignedTransactionBundle, delay?: number, maxFails?: number, isCancelled?: () => boolean): Promise<proto.GetMetaTxnReceiptReturn>;
@@ -24,7 +24,7 @@ export declare class RpcRelayer implements Relayer {
         options: FeeOption[];
         quote?: FeeQuote;
     }>;
-    getFeeOptionsRaw(entrypoint: string, data: ethers.utils.BytesLike, options?: {
+    getFeeOptionsRaw(entrypoint: string, data: ethers.BytesLike, options?: {
         simulate?: boolean;
     }): Promise<{
         options: FeeOption[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xsequence/relayer",
-  "version": "1.10.15",
+  "version": "2.0.0",
   "description": "relayer sub-package for Sequence",
   "repository": "https://github.com/0xsequence/sequence.js/tree/master/packages/relayer",
   "source": "src/index.ts",
@@ -9,18 +9,18 @@
   "author": "Horizon Blockchain Games",
   "license": "Apache-2.0",
   "dependencies": {
-    "@0xsequence/abi": "1.10.15",
-    "@0xsequence/core": "1.10.15",
-    "@0xsequence/utils": "1.10.15"
+    "@0xsequence/abi": "2.0.0",
+    "@0xsequence/core": "2.0.0",
+    "@0xsequence/utils": "2.0.0"
   },
   "peerDependencies": {
-    "ethers": ">=5.5 < 6"
+    "ethers": ">=6"
   },
   "devDependencies": {
-    "@0xsequence/wallet-contracts": "^1.10.0",
-    "ethers": "^5.7.2",
-    "@0xsequence/signhub": "1.10.15",
-    "@0xsequence/tests": "1.10.15"
+    "@0xsequence/wallet-contracts": "^3.0.1",
+    "ethers": "^6.13.0",
+    "@0xsequence/signhub": "2.0.0",
+    "@0xsequence/tests": "2.0.0"
   },
   "files": [
     "src",
@@ -29,7 +29,7 @@
   "scripts": {
     "test": "pnpm test:concurrently 'pnpm test:run'",
     "test:run": "pnpm test:file tests/**/*.spec.ts",
-    "test:file": "NODE_OPTIONS='--import tsx' mocha --timeout 30000",
+    "test:file": "NODE_OPTIONS='--import tsx' mocha --timeout 60000",
     "test:concurrently": "concurrently -k --success first 'pnpm start:hardhat > /dev/null' ",
     "start:hardhat": "pnpm hardhat node --port 9547",
     "typecheck": "tsc --noEmit"

package/src/index.ts

@@ -1,4 +1,4 @@
-import { ethers, providers } from 'ethers'
+import { ethers } from 'ethers'
 import { proto } from './rpc-relayer'
 
 import { commons } from '@0xsequence/core'
@@ -19,7 +19,7 @@ export interface Relayer {
   // It doesn't make any assumptions about the transaction format.
   getFeeOptionsRaw(
     entrypoint: string,
-    data: ethers.utils.BytesLike,
+    data: ethers.BytesLike,
     options?: {
       simulate?: boolean
     }
@@ -32,7 +32,7 @@ export interface Relayer {
   // getNonce returns the transaction count/nonce for a wallet, encoded with nonce space.
   // If space is undefined, the relayer can choose a nonce space to encode the result with.
   // Otherwise, the relayer must return a nonce encoded for the given nonce space.
-  getNonce(address: string, space?: ethers.BigNumberish, blockTag?: providers.BlockTag): Promise<ethers.BigNumberish>
+  getNonce(address: string, space?: ethers.BigNumberish, blockTag?: ethers.BlockTag): Promise<ethers.BigNumberish>
 
   // relayer will submit the transaction(s) to the network and return the transaction response.
   // The quote should be the one returned from getFeeOptions, if any.

package/src/local-relayer.ts

@@ -1,24 +1,28 @@
-import { Signer as AbstractSigner, providers, BytesLike } from 'ethers'
+import { ethers } from 'ethers'
 import { logger } from '@0xsequence/utils'
 import { FeeOption, FeeQuote, Relayer } from '.'
 import { ProviderRelayer, ProviderRelayerOptions } from './provider-relayer'
 import { commons } from '@0xsequence/core'
 
 export type LocalRelayerOptions = Omit<ProviderRelayerOptions, 'provider'> & {
-  signer: AbstractSigner
+  signer: ethers.Signer
 }
 
 export function isLocalRelayerOptions(obj: any): obj is LocalRelayerOptions {
-  return obj.signer !== undefined && AbstractSigner.isSigner(obj.signer)
+  return typeof obj === 'object' && obj.signer instanceof ethers.AbstractSigner
 }
 
 export class LocalRelayer extends ProviderRelayer implements Relayer {
-  private signer: AbstractSigner
-  private txnOptions: providers.TransactionRequest
+  private signer: ethers.Signer
+  private txnOptions: ethers.TransactionRequest
 
-  constructor(options: LocalRelayerOptions | AbstractSigner) {
-    super(AbstractSigner.isSigner(options) ? { provider: options.provider! } : { ...options, provider: options.signer.provider! })
-    this.signer = AbstractSigner.isSigner(options) ? options : options.signer
+  constructor(options: LocalRelayerOptions | ethers.AbstractSigner) {
+    super(
+      options instanceof ethers.AbstractSigner
+        ? { provider: options.provider! }
+        : { ...options, provider: options.signer.provider! }
+    )
+    this.signer = options instanceof ethers.AbstractSigner ? options : options.signer
     if (!this.signer.provider) throw new Error('Signer must have a provider')
   }
 
@@ -28,7 +32,7 @@ export class LocalRelayer extends ProviderRelayer implements Relayer {
 
   async getFeeOptionsRaw(
     _entrypoint: string,
-    _data: BytesLike,
+    _data: ethers.BytesLike,
     _options?: {
       simulate?: boolean
     }
@@ -41,7 +45,7 @@ export class LocalRelayer extends ProviderRelayer implements Relayer {
     return options
   }
 
-  setTransactionOptions(transactionRequest: providers.TransactionRequest) {
+  setTransactionOptions(transactionRequest: ethers.TransactionRequest) {
     this.txnOptions = transactionRequest
   }
 
@@ -49,7 +53,7 @@ export class LocalRelayer extends ProviderRelayer implements Relayer {
     signedTxs: commons.transaction.IntendedTransactionBundle,
     quote?: FeeQuote,
     waitForReceipt: boolean = true
-  ): Promise<commons.transaction.TransactionResponse<providers.TransactionReceipt>> {
+  ): Promise<commons.transaction.TransactionResponse<ethers.TransactionReceipt>> {
     if (quote !== undefined) {
       logger.warn(`LocalRelayer doesn't accept fee quotes`)
     }
@@ -58,7 +62,7 @@ export class LocalRelayer extends ProviderRelayer implements Relayer {
 
     // TODO: think about computing gas limit individually, summing together and passing across
     // NOTE: we expect that all txns have set their gasLimit ahead of time through proper estimation
-    // const gasLimit = signedTxs.transactions.reduce((sum, tx) => sum.add(tx.gasLimit), ethers.BigNumber.from(0))
+    // const gasLimit = signedTxs.transactions.reduce((sum, tx) => sum + tx.gasLimit, 0n)
     // txRequest.gasLimit = gasLimit
 
     const responsePromise = this.signer.sendTransaction({

package/src/provider-relayer.ts

@@ -1,13 +1,13 @@
-import { ethers, providers } from 'ethers'
+import { ethers } from 'ethers'
 import { walletContracts } from '@0xsequence/abi'
 import { FeeOption, FeeQuote, Relayer, SimulateResult } from '.'
 import { logger, Optionals } from '@0xsequence/utils'
 import { commons } from '@0xsequence/core'
 
-const DEFAULT_GAS_LIMIT = ethers.BigNumber.from(800000)
+const DEFAULT_GAS_LIMIT = 800000n
 
 export interface ProviderRelayerOptions {
-  provider: providers.Provider
+  provider: ethers.Provider
   waitPollRate?: number
   deltaBlocksLog?: number
   fromBlockLog?: number
@@ -20,11 +20,11 @@ export const ProviderRelayerDefaults: Required<Optionals<ProviderRelayerOptions>
 }
 
 export function isProviderRelayerOptions(obj: any): obj is ProviderRelayerOptions {
-  return obj.provider !== undefined && providers.Provider.isProvider(obj.provider)
+  return typeof obj === 'object' && obj.provider instanceof ethers.AbstractProvider
 }
 
 export abstract class ProviderRelayer implements Relayer {
-  public provider: providers.Provider
+  public provider: ethers.Provider
   public waitPollRate: number
   public deltaBlocksLog: number
   public fromBlockLog: number
@@ -45,7 +45,7 @@ export abstract class ProviderRelayer implements Relayer {
 
   abstract getFeeOptionsRaw(
     entrypoint: string,
-    data: ethers.utils.BytesLike,
+    data: ethers.BytesLike,
     options?: {
       simulate?: boolean
     }
@@ -64,7 +64,7 @@ export abstract class ProviderRelayer implements Relayer {
       await Promise.all(
         transactions.map(async tx => {
           // Respect gasLimit request of the transaction (as long as its not 0)
-          if (tx.gasLimit && !ethers.BigNumber.from(tx.gasLimit || 0).eq(ethers.constants.Zero)) {
+          if (tx.gasLimit && BigInt(tx.gasLimit || 0) !== 0n) {
             return tx.gasLimit
           }
 
@@ -74,7 +74,7 @@ export abstract class ProviderRelayer implements Relayer {
           }
 
           // Fee can't be estimated for self-called if wallet hasn't been deployed
-          if (tx.to === wallet && (await this.provider.getCode(wallet).then(code => ethers.utils.arrayify(code).length === 0))) {
+          if (tx.to === wallet && (await this.provider.getCode(wallet).then(code => ethers.getBytes(code).length === 0))) {
             return DEFAULT_GAS_LIMIT
           }
 
@@ -95,12 +95,12 @@ export abstract class ProviderRelayer implements Relayer {
     ).map(gasLimit => ({
       executed: true,
       succeeded: true,
-      gasUsed: ethers.BigNumber.from(gasLimit).toNumber(),
-      gasLimit: ethers.BigNumber.from(gasLimit).toNumber()
+      gasUsed: Number(gasLimit),
+      gasLimit: Number(gasLimit)
     }))
   }
 
-  async getNonce(address: string, space?: ethers.BigNumberish, blockTag?: providers.BlockTag): Promise<ethers.BigNumberish> {
+  async getNonce(address: string, space?: ethers.BigNumberish, blockTag?: ethers.BlockTag): Promise<ethers.BigNumberish> {
     if (!this.provider) {
       throw new Error('provider is not set')
     }
@@ -123,7 +123,7 @@ export abstract class ProviderRelayer implements Relayer {
     timeoutDuration?: number,
     delay: number = this.waitPollRate,
     maxFails: number = 5
-  ): Promise<providers.TransactionResponse & { receipt: providers.TransactionReceipt }> {
+  ): Promise<ethers.TransactionResponse & { receipt: ethers.TransactionReceipt }> {
     if (typeof metaTxnId !== 'string') {
       metaTxnId = commons.transaction.intendedTransactionID(metaTxnId)
     }
@@ -155,7 +155,7 @@ export abstract class ProviderRelayer implements Relayer {
       throw new Error(`timed out after ${fails} failed attempts${errorMessage ? `: ${errorMessage}` : ''}`)
     }
 
-    const waitReceipt = async (): Promise<providers.TransactionResponse & { receipt: providers.TransactionReceipt }> => {
+    const waitReceipt = async (): Promise<ethers.TransactionResponse & { receipt: ethers.TransactionReceipt }> => {
       // Transactions can only get executed on nonce change
       // get all nonce changes and look for metaTxnIds in between logs
       let lastBlock: number = this.fromBlockLog
@@ -199,7 +199,7 @@ export abstract class ProviderRelayer implements Relayer {
 
         // Find a transaction with a TxExecuted log
         const found = txs.find(tx =>
-          tx.logs.find(
+          tx?.logs.find(
             l =>
               (l.topics.length === 0 && l.data.replace('0x', '') === normalMetaTxnId) ||
               (l.topics.length === 1 &&
@@ -212,13 +212,17 @@ export abstract class ProviderRelayer implements Relayer {
 
         // If found return that
         if (found) {
-          return {
-            receipt: found,
-            ...(await retry(
-              () => this.provider.getTransaction(found.transactionHash),
-              `unable to get transaction ${found.transactionHash}`
-            ))
+          const response = await retry(() => this.provider.getTransaction(found.hash), `unable to get transaction ${found.hash}`)
+          if (!response) {
+            throw new Error(`Transaction response not found for  ${metaTxnId}`)
           }
+
+          // NOTE: we have to do this, because ethers-v6 uses private fields
+          // and we can't just extend the class and override the method, so
+          // we just modify the response object directly by adding the receipt to it.
+          const out: any = response
+          out.receipt = found
+          return out
         }
 
         // Otherwise wait and try again
@@ -233,7 +237,7 @@ export abstract class ProviderRelayer implements Relayer {
     if (timeoutDuration !== undefined) {
       return Promise.race([
         waitReceipt(),
-        new Promise<providers.TransactionResponse & { receipt: providers.TransactionReceipt }>((_, reject) =>
+        new Promise<ethers.TransactionResponse & { receipt: ethers.TransactionReceipt }>((_, reject) =>
           setTimeout(() => {
             timedOut = true
             reject(`Timeout waiting for transaction receipt ${metaTxnId}`)

package/src/rpc-relayer/index.ts

@@ -2,7 +2,7 @@ import { ethers } from 'ethers'
 import { FeeOption, FeeQuote, Relayer, SimulateResult } from '..'
 import * as proto from './relayer.gen'
 import { commons } from '@0xsequence/core'
-import { getEthersConnectionInfo, logger } from '@0xsequence/utils'
+import { getFetchRequest, logger, toHexString } from '@0xsequence/utils'
 
 export { proto }
 
@@ -16,7 +16,7 @@ const FINAL_STATUSES = [
 const FAILED_STATUSES = [proto.ETHTxnStatus.DROPPED, proto.ETHTxnStatus.PARTIALLY_FAILED, proto.ETHTxnStatus.FAILED]
 
 export interface RpcRelayerOptions {
-  provider: ethers.providers.Provider | { url: string }
+  provider: ethers.AbstractProvider | { url: string }
   url: string
   projectAccessKey?: string
   jwtAuth?: string
@@ -27,7 +27,7 @@ export function isRpcRelayerOptions(obj: any): obj is RpcRelayerOptions {
     obj.url !== undefined &&
     typeof obj.url === 'string' &&
     obj.provider !== undefined &&
-    ethers.providers.Provider.isProvider(obj.provider)
+    obj.provider instanceof ethers.AbstractProvider
   )
 }
 
@@ -36,17 +36,17 @@ const fetch = globalThis.fetch
 // TODO: rename to SequenceRelayer
 export class RpcRelayer implements Relayer {
   private readonly service: proto.Relayer
-  public readonly provider: ethers.providers.Provider
+  public readonly provider: ethers.Provider
 
   constructor(public options: RpcRelayerOptions) {
     this.service = new proto.Relayer(options.url, this._fetch)
 
-    if (ethers.providers.Provider.isProvider(options.provider)) {
+    if (options.provider instanceof ethers.AbstractProvider) {
       this.provider = options.provider
     } else {
       const { jwtAuth, projectAccessKey } = this.options
-      const providerConnectionInfo = getEthersConnectionInfo(options.provider.url, projectAccessKey, jwtAuth)
-      this.provider = new ethers.providers.StaticJsonRpcProvider(providerConnectionInfo)
+      const fetchRequest = getFetchRequest(options.provider.url, projectAccessKey, jwtAuth)
+      this.provider = new ethers.JsonRpcProvider(fetchRequest, undefined, { staticNetwork: true })
     }
   }
 
@@ -114,7 +114,7 @@ export class RpcRelayer implements Relayer {
   }
 
   async simulate(wallet: string, ...transactions: commons.transaction.Transaction[]): Promise<SimulateResult[]> {
-    const coder = ethers.utils.defaultAbiCoder
+    const coder = ethers.AbiCoder.defaultAbiCoder()
     const encoded = coder.encode(
       [commons.transaction.MetaTransactionsType],
       [commons.transaction.sequenceTxAbiEncode(transactions)]
@@ -162,7 +162,7 @@ export class RpcRelayer implements Relayer {
 
   async getFeeOptionsRaw(
     entrypoint: string,
-    data: ethers.utils.BytesLike,
+    data: ethers.BytesLike,
     options?: {
       simulate?: boolean
     }
@@ -170,7 +170,7 @@ export class RpcRelayer implements Relayer {
     const { options: feeOptions, quote } = await this.service.feeOptions({
       wallet: entrypoint,
       to: entrypoint,
-      data: ethers.utils.hexlify(data),
+      data: ethers.hexlify(data),
       simulate: options?.simulate
     })
 
@@ -184,9 +184,9 @@ export class RpcRelayer implements Relayer {
 
   async getNonce(address: string, space?: ethers.BigNumberish): Promise<ethers.BigNumberish> {
     logger.info(`[rpc-relayer/getNonce] get nonce for wallet ${address} space: ${space}`)
-    const encodedNonce = space !== undefined ? ethers.BigNumber.from(space).toHexString() : undefined
+    const encodedNonce = space !== undefined ? toHexString(BigInt(space)) : undefined
     const resp = await this.service.getMetaTxnNonce({ walletContractAddress: address, space: encodedNonce })
-    const nonce = ethers.BigNumber.from(resp.nonce)
+    const nonce = BigInt(resp.nonce)
     const [decodedSpace, decodedNonce] = commons.transaction.decodeNonce(nonce)
     logger.info(`[rpc-relayer/getNonce] got next nonce for wallet ${address} ${decodedNonce} space: ${decodedSpace}`)
     return nonce
@@ -234,10 +234,10 @@ export class RpcRelayer implements Relayer {
         hash: signedTxs.intent.id,
         confirmations: 0,
         from: signedTxs.intent.wallet,
-        wait: (_confirmations?: number): Promise<ethers.providers.TransactionReceipt> => Promise.reject(new Error('impossible'))
+        wait: (_confirmations?: number): Promise<ethers.TransactionReceipt | null> => Promise.reject(new Error('impossible'))
       }
 
-      const wait = async (confirmations?: number): Promise<ethers.providers.TransactionReceipt> => {
+      const wait = async (confirmations?: number): Promise<ethers.TransactionReceipt | null> => {
         if (!this.provider) {
           throw new Error('cannot wait for receipt, relayer has no provider set')
         }
@@ -256,6 +256,9 @@ export class RpcRelayer implements Relayer {
 
       response.wait = wait
 
+      // NOTE: we just ignore these errors which come from the private fields
+      // of ethers-v6 .. but, we should probably rework this instead..
+      // @ts-ignore
       return response as commons.transaction.TransactionResponse
     }
   }
@@ -286,9 +289,12 @@ export class RpcRelayer implements Relayer {
 
     const txReceipt = JSON.parse(receipt.txnReceipt) as RelayerTxReceipt
 
+    // NOTE: we just ignore these errors which come from the private fields
+    // of ethers-v6 .. but, we should probably rework this instead..
+    // @ts-ignore
     return {
       blockHash: txReceipt.blockHash,
-      blockNumber: ethers.BigNumber.from(txReceipt.blockNumber).toNumber(),
+      blockNumber: Number(txReceipt.blockNumber),
       confirmations: 1,
       from: typeof metaTxnId === 'string' ? undefined : metaTxnId.intent.wallet,
       hash: txReceipt.transactionHash,