feat: update ethers@6

fix: bigint errors

fix: TS errors

fix: gasLimit fetch

fix: review comments

fix: contracts errors

chore: bump rc version

fix: revert wrong fix

fix: ts config

fix: ts config

fix: ts config

feat: update signer

src/services/Aggregator/index.ts

@@ -74,13 +74,13 @@ class Aggregator {
   }
 
   getOrder = (orderId: string, owner?: string) => {
-    if (!ethers.utils.isHexString(orderId)) {
+    if (!ethers.isHexString(orderId)) {
       throw new Error(`Invalid order id: ${orderId}. Must be a hex string`);
     }
     const url = new URL(`${this.apiUrl}/api/v1/order`);
     url.searchParams.append('orderId', orderId);
     if (owner !== undefined) {
-      if (!ethers.utils.isAddress(owner)) {
+      if (!ethers.isAddress(owner)) {
         throw new Error(`Invalid owner address: ${owner}`);
       }
       url.searchParams.append('owner', owner);

src/services/Aggregator/schemas/orderSchema.ts

@@ -3,22 +3,22 @@ import { z } from 'zod';
 import { exchanges, orderStatuses, subOrderStatuses } from '../../../constants/index.js';
 
 const blockchainOrderSchema = z.object({
-  id: z.string().refine(ethers.utils.isHexString, (value) => ({
+  id: z.string().refine(ethers.isHexString, (value) => ({
     message: `blockchainOrder.id must be a hex string, got ${value}`,
   })),
-  senderAddress: z.string().refine(ethers.utils.isAddress, (value) => ({
+  senderAddress: z.string().refine(ethers.isAddress, (value) => ({
     message: `blockchainOrder.senderAddress must be an address, got ${value}`,
   })),
-  matcherAddress: z.string().refine(ethers.utils.isAddress, (value) => ({
+  matcherAddress: z.string().refine(ethers.isAddress, (value) => ({
     message: `blockchainOrder.matcherAddress must be an address, got ${value}`,
   })),
-  baseAsset: z.string().refine(ethers.utils.isAddress, (value) => ({
+  baseAsset: z.string().refine(ethers.isAddress, (value) => ({
     message: `blockchainOrder.baseAsset must be an address, got ${value}`,
   })),
-  quoteAsset: z.string().refine(ethers.utils.isAddress, (value) => ({
+  quoteAsset: z.string().refine(ethers.isAddress, (value) => ({
     message: `blockchainOrder.quoteAsset must be an address, got ${value}`,
   })),
-  matcherFeeAsset: z.string().refine(ethers.utils.isAddress, (value) => ({
+  matcherFeeAsset: z.string().refine(ethers.isAddress, (value) => ({
     message: `blockchainOrder.matcherFeeAsset must be an address, got ${value}`,
   })),
   amount: z.number().int().nonnegative(),
@@ -27,7 +27,7 @@ const blockchainOrderSchema = z.object({
   nonce: z.number(),
   expiration: z.number(),
   buySide: z.union([z.literal(1), z.literal(0)]),
-  signature: z.string().refine(ethers.utils.isHexString, (value) => ({
+  signature: z.string().refine(ethers.isHexString, (value) => ({
     message: `blockchainOrder.signature must be a hex string, got ${value}`,
   })).nullable(),
   isPersonalSign: z.boolean(),
@@ -53,7 +53,7 @@ const baseOrderSchema = z.object({
   amount: z.number().nonnegative(),
   remainingAmount: z.number().nonnegative(),
   price: z.number().nonnegative(),
-  sender: z.string().refine(ethers.utils.isAddress, (value) => ({
+  sender: z.string().refine(ethers.isAddress, (value) => ({
     message: `order.sender must be an address, got ${value}`,
   })),
   filledAmount: z.number().nonnegative(),
@@ -77,13 +77,13 @@ const brokerAddressSchema = z.enum([
   'SELF_BROKER'
 ])
   .or(selfBrokerSchema)
-  .or(z.string().refine(ethers.utils.isAddress, (value) => ({
+  .or(z.string().refine(ethers.isAddress, (value) => ({
     message: `subOrder.subOrders.[n].brokerAddress must be an address, got ${value}`,
   })));
 const subOrderSchema = baseOrderSchema.extend({
   price: z.number(),
   id: z.number(),
-  parentOrderId: z.string().refine(ethers.utils.isHexString, (value) => ({
+  parentOrderId: z.string().refine(ethers.isHexString, (value) => ({
     message: `subOrder.parentOrderId must be a hex string, got ${value}`,
   })),
   exchange: z.string(),
@@ -98,11 +98,11 @@ const subOrderSchema = baseOrderSchema.extend({
 });
 
 const orderSchema = z.object({
-  orderId: z.string().refine(ethers.utils.isHexString, (value) => ({
+  orderId: z.string().refine(ethers.isHexString, (value) => ({
     message: `orderId must be a hex string, got ${value}`,
   })),
   order: baseOrderSchema.extend({
-    id: z.string().refine(ethers.utils.isHexString, (value) => ({
+    id: z.string().refine(ethers.isHexString, (value) => ({
       message: `order.id must be a hex string, got ${value}`,
     })),
     fee: z.number().nonnegative(),

src/services/BlockchainService/schemas/atomicHistorySchema.ts

@@ -16,9 +16,9 @@ const baseAtomicHistoryItem = z.object({
   _id: z.string(),
   __v: z.number(),
   asset: z.string(),
-  sender: z.string().refine(ethers.utils.isAddress),
-  secretHash: z.string().refine(ethers.utils.isHexString),
-  receiver: z.string().refine(ethers.utils.isAddress).optional(),
+  sender: z.string().refine(ethers.isAddress),
+  secretHash: z.string().refine(ethers.isHexString),
+  receiver: z.string().refine(ethers.isAddress).optional(),
   secret: z.string().optional(),
 });
 

src/services/ReferralSystem/schemas/contractsAddressesSchema.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 import { SupportedChainId } from '../../../types.js';
-import { isAddress } from 'ethers/lib/utils.js';
+import { ethers } from 'ethers';
 
 const contractsAddressesSchema = z.record(
   z.nativeEnum(SupportedChainId),
-  z.string().refine(isAddress)
+  z.string().refine(ethers.isAddress)
 );
 
 export default contractsAddressesSchema;