@across-protocol/sdk 3.1.28-beta.1 → 3.1.28

package/dist/types/utils/abi/typechain/factories/Multicall3__factory.d.ts

@@ -0,0 +1,340 @@
+import { Signer } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type { Multicall3, Multicall3Interface } from "../Multicall3";
+export declare class Multicall3__factory {
+    static readonly abi: readonly [{
+        readonly inputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "address";
+                readonly name: "target";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "callData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Call[]";
+            readonly name: "calls";
+            readonly type: "tuple[]";
+        }];
+        readonly name: "aggregate";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "blockNumber";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes[]";
+            readonly name: "returnData";
+            readonly type: "bytes[]";
+        }];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "address";
+                readonly name: "target";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bool";
+                readonly name: "allowFailure";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "callData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Call3[]";
+            readonly name: "calls";
+            readonly type: "tuple[]";
+        }];
+        readonly name: "aggregate3";
+        readonly outputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "bool";
+                readonly name: "success";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "returnData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Result[]";
+            readonly name: "returnData";
+            readonly type: "tuple[]";
+        }];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "address";
+                readonly name: "target";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bool";
+                readonly name: "allowFailure";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "value";
+                readonly type: "uint256";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "callData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Call3Value[]";
+            readonly name: "calls";
+            readonly type: "tuple[]";
+        }];
+        readonly name: "aggregate3Value";
+        readonly outputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "bool";
+                readonly name: "success";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "returnData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Result[]";
+            readonly name: "returnData";
+            readonly type: "tuple[]";
+        }];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "address";
+                readonly name: "target";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "callData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Call[]";
+            readonly name: "calls";
+            readonly type: "tuple[]";
+        }];
+        readonly name: "blockAndAggregate";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "blockNumber";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "blockHash";
+            readonly type: "bytes32";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "bool";
+                readonly name: "success";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "returnData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Result[]";
+            readonly name: "returnData";
+            readonly type: "tuple[]";
+        }];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "getBasefee";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "basefee";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "blockNumber";
+            readonly type: "uint256";
+        }];
+        readonly name: "getBlockHash";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "blockHash";
+            readonly type: "bytes32";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "getBlockNumber";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "blockNumber";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "getChainId";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "chainid";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "getCurrentBlockCoinbase";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "coinbase";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "getCurrentBlockDifficulty";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "difficulty";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "getCurrentBlockGasLimit";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "gaslimit";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "getCurrentBlockTimestamp";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "timestamp";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "addr";
+            readonly type: "address";
+        }];
+        readonly name: "getEthBalance";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "balance";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "getLastBlockHash";
+        readonly outputs: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "blockHash";
+            readonly type: "bytes32";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "requireSuccess";
+            readonly type: "bool";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "address";
+                readonly name: "target";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "callData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Call[]";
+            readonly name: "calls";
+            readonly type: "tuple[]";
+        }];
+        readonly name: "tryAggregate";
+        readonly outputs: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "bool";
+                readonly name: "success";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "returnData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Result[]";
+            readonly name: "returnData";
+            readonly type: "tuple[]";
+        }];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "bool";
+            readonly name: "requireSuccess";
+            readonly type: "bool";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "address";
+                readonly name: "target";
+                readonly type: "address";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "callData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Call[]";
+            readonly name: "calls";
+            readonly type: "tuple[]";
+        }];
+        readonly name: "tryBlockAndAggregate";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "blockNumber";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "blockHash";
+            readonly type: "bytes32";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "bool";
+                readonly name: "success";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "returnData";
+                readonly type: "bytes";
+            }];
+            readonly internalType: "struct Multicall3.Result[]";
+            readonly name: "returnData";
+            readonly type: "tuple[]";
+        }];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }];
+    static createInterface(): Multicall3Interface;
+    static connect(address: string, signerOrProvider: Signer | Provider): Multicall3;
+}
+//# sourceMappingURL=Multicall3__factory.d.ts.map

package/dist/types/utils/abi/typechain/factories/Multicall3__factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Multicall3__factory.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/abi/typechain/factories/Multicall3__factory.ts"],"names":[],"mappings":"AAIA,OAAO,EAAY,MAAM,EAAS,MAAM,QAAQ,CAAC;AACjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AA2brE,qBAAa,mBAAmB;IAC9B,MAAM,CAAC,QAAQ,CAAC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAAQ;IAC3B,MAAM,CAAC,eAAe,IAAI,mBAAmB;IAG7C,MAAM,CAAC,OAAO,CACZ,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,MAAM,GAAG,QAAQ,GAClC,UAAU;CAGd"}

package/dist/types/utils/abi/typechain/factories/index.d.ts

@@ -0,0 +1,2 @@
+export { Multicall3__factory } from "./Multicall3__factory";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/utils/abi/typechain/factories/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/abi/typechain/factories/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/types/utils/abi/typechain/index.d.ts

@@ -0,0 +1,4 @@
+export type { Multicall3 } from "./Multicall3";
+export * as factories from "./factories";
+export { Multicall3__factory } from "./factories/Multicall3__factory";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/utils/abi/typechain/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/utils/abi/typechain/index.ts"],"names":[],"mappings":"AAGA,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "3.1.28-beta.1",
+  "version": "3.1.28",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "files": [
@@ -13,13 +13,10 @@
   },
   "scripts": {
     "start": "nodemon -e ts,tsx,json,js,jsx --watch ./src --ignore ./dist --exec 'yarn build'",
-    "build": "yarn run clean && yarn run build:cjs & yarn run build:esm & yarn run build:types; wait",
-    "build:cjs": "tsc --project tsconfig.build.json --module commonjs --outDir ./dist/cjs --removeComments --verbatimModuleSyntax false && echo > ./dist/cjs/package.json '{\"type\":\"commonjs\"}' && yarn copy-abi:cjs",
-    "build:esm": "tsc --project tsconfig.build.json --module es2015 --outDir ./dist/esm && echo > ./dist/esm/package.json '{\"type\":\"module\",\"sideEffects\":false}' && yarn copy-abi:esm",
+    "build": "yarn run clean && yarn typechain && yarn run build:cjs & yarn run build:esm & yarn run build:types; wait",
+    "build:cjs": "tsc --project tsconfig.build.json --module commonjs --outDir ./dist/cjs --removeComments --verbatimModuleSyntax false && echo > ./dist/cjs/package.json '{\"type\":\"commonjs\"}'",
+    "build:esm": "tsc --project tsconfig.build.json --module es2015 --outDir ./dist/esm && echo > ./dist/esm/package.json '{\"type\":\"module\",\"sideEffects\":false}'",
     "build:types": "tsc --project tsconfig.build.json --module esnext --declarationDir ./dist/types --emitDeclarationOnly --declaration --declarationMap",
-    "copy-abi:cjs": "DIR=cjs yarn copy-abi",
-    "copy-abi:esm": "DIR=esm yarn copy-abi",
-    "copy-abi": "abi=utils/abi/contracts; dstdir=\"./dist/${DIR}/${abi}\"; mkdir -p \"${dstdir}\"; cp ./src/${abi}/*.json \"${dstdir}\"",
     "test": "hardhat test",
     "test:watch": "hardhat watch test",
     "test:run:arweave": "npx -y arlocal",
@@ -31,7 +28,8 @@
     "clean": "rm -rf ./dist",
     "bump-version:major": "yarn version --major --no-git-tag-version --no-commit-hooks && git commit -m 'chore: bump version' ./package.json --no-verify",
     "bump-version:minor": "yarn version --minor --no-git-tag-version --no-commit-hooks && git commit -m 'chore: bump version' ./package.json --no-verify",
-    "bump-version:patch": "yarn version --patch --no-git-tag-version --no-commit-hooks && git commit -m 'chore: bump version' ./package.json --no-verify"
+    "bump-version:patch": "yarn version --patch --no-git-tag-version --no-commit-hooks && git commit -m 'chore: bump version' ./package.json --no-verify",
+    "typechain": "typechain --target ethers-v5 --out-dir src/utils/abi/typechain 'src/utils/abi/contracts/*.json' && eslint --fix src/utils/abi/typechain && yarn prettier --write \"src/utils/abi/typechain/**/*.ts\""
   },
   "lint-staged": {
     "*.ts": "yarn lint"

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -30,6 +30,7 @@ import {
   isSlowFill,
   mapAsync,
   relayFillStatus,
+  bnUint32Max,
 } from "../../utils";
 import { BigNumber } from "ethers";
 import winston from "winston";
@@ -47,6 +48,9 @@ import {
   V3FillWithBlock,
 } from "./utils";
 
+// max(uint256) - 1
+export const INFINITE_FILL_DEADLINE = bnUint32Max;
+
 type DataCache = Record<string, Promise<LoadDataReturnValue>>;
 
 // V3 dictionary helper functions
@@ -766,44 +770,40 @@ export class BundleDataClient {
         if (originChainId === destinationChainId) {
           continue;
         }
-
-        originClient
-          .getDepositsForDestinationChain(destinationChainId)
-          .filter((deposit) => deposit.blockNumber <= originChainBlockRange[1])
-          .forEach((deposit) => {
-            depositCounter++;
-            const relayDataHash = this.getRelayHashFromEvent(deposit);
-            if (v3RelayHashes[relayDataHash]) {
-              // If we've seen this deposit before, then skip this deposit. This can happen if our RPC provider
-              // gives us bad data.
-              return;
-            }
-            // Even if deposit is not in bundle block range, store all deposits we can see in memory in this
-            // convenient dictionary.
-            v3RelayHashes[relayDataHash] = {
-              deposit: deposit,
-              fill: undefined,
-              slowFillRequest: undefined,
-            };
-
-            // If deposit block is within origin chain bundle block range, then save as bundle deposit.
-            // If deposit is in bundle and it has expired, additionally save it as an expired deposit.
-            // If deposit is not in the bundle block range, then save it as an older deposit that
-            // may have expired.
-            if (deposit.blockNumber >= originChainBlockRange[0]) {
-              // Deposit is a V3 deposit in this origin chain's bundle block range and is not a duplicate.
-              updateBundleDepositsV3(bundleDepositsV3, deposit);
-              // We don't check that fillDeadline >= bundleBlockTimestamps[destinationChainId][0] because
-              // that would eliminate any deposits in this bundle with a very low fillDeadline like equal to 0
-              // for example. Those should be impossible to create but technically should be included in this
-              // bundle of refunded deposits.
-              if (deposit.fillDeadline < bundleBlockTimestamps[destinationChainId][1]) {
-                expiredBundleDepositHashes.add(relayDataHash);
-              }
-            } else {
-              olderDepositHashes.add(relayDataHash);
+        originClient.getDepositsForDestinationChain(destinationChainId).forEach((deposit) => {
+          depositCounter++;
+          const relayDataHash = this.getRelayHashFromEvent(deposit);
+          if (v3RelayHashes[relayDataHash]) {
+            // If we've seen this deposit before, then skip this deposit. This can happen if our RPC provider
+            // gives us bad data.
+            return;
+          }
+          // Even if deposit is not in bundle block range, store all deposits we can see in memory in this
+          // convenient dictionary.
+          v3RelayHashes[relayDataHash] = {
+            deposit: deposit,
+            fill: undefined,
+            slowFillRequest: undefined,
+          };
+
+          // If deposit block is within origin chain bundle block range, then save as bundle deposit.
+          // If deposit is in bundle and it has expired, additionally save it as an expired deposit.
+          // If deposit is not in the bundle block range, then save it as an older deposit that
+          // may have expired.
+          if (deposit.blockNumber >= originChainBlockRange[0] && deposit.blockNumber <= originChainBlockRange[1]) {
+            // Deposit is a V3 deposit in this origin chain's bundle block range and is not a duplicate.
+            updateBundleDepositsV3(bundleDepositsV3, deposit);
+            // We don't check that fillDeadline >= bundleBlockTimestamps[destinationChainId][0] because
+            // that would eliminate any deposits in this bundle with a very low fillDeadline like equal to 0
+            // for example. Those should be impossible to create but technically should be included in this
+            // bundle of refunded deposits.
+            if (deposit.fillDeadline < bundleBlockTimestamps[destinationChainId][1]) {
+              expiredBundleDepositHashes.add(relayDataHash);
             }
-          });
+          } else if (deposit.blockNumber < originChainBlockRange[0]) {
+            olderDepositHashes.add(relayDataHash);
+          }
+        });
       }
     }
     this.logger.debug({
@@ -877,7 +877,16 @@ export class BundleDataClient {
 
             // Since there was no deposit matching the relay hash, we need to do a historical query for an
             // older deposit in case the spoke pool client's lookback isn't old enough to find the matching deposit.
+            // We can skip this step if the fill's fill deadline is not infinite, because we can assume that the
+            // spoke pool clients have loaded deposits old enough to cover all fills with a non-infinite fill deadline.
             if (fill.blockNumber >= destinationChainBlockRange[0]) {
+              // Fill has a non-infinite expiry, and we can assume our spoke pool clients have old enough deposits
+              // to conclude that this fill is invalid if we haven't found a matching deposit in memory, so
+              // skip the historical query.
+              if (!INFINITE_FILL_DEADLINE.eq(fill.fillDeadline)) {
+                bundleInvalidFillsV3.push(fill);
+                return;
+              }
               const historicalDeposit = await queryHistoricalDepositForFill(originClient, fill);
               if (!historicalDeposit.found) {
                 bundleInvalidFillsV3.push(fill);
@@ -975,7 +984,12 @@ export class BundleDataClient {
 
             // Since there was no deposit matching the relay hash, we need to do a historical query for an
             // older deposit in case the spoke pool client's lookback isn't old enough to find the matching deposit.
-            if (slowFillRequest.blockNumber >= destinationChainBlockRange[0]) {
+            // We can skip this step if the deposit's fill deadline is not infinite, because we can assume that the
+            // spoke pool clients have loaded deposits old enough to cover all fills with a non-infinite fill deadline.
+            if (
+              INFINITE_FILL_DEADLINE.eq(slowFillRequest.fillDeadline) &&
+              slowFillRequest.blockNumber >= destinationChainBlockRange[0]
+            ) {
               const historicalDeposit = await queryHistoricalDepositForFill(originClient, slowFillRequest);
               if (!historicalDeposit.found) {
                 // TODO: Invalid slow fill request. Maybe worth logging.
@@ -1103,7 +1117,7 @@ export class BundleDataClient {
           // the block ranges passed into this function would never contain blocks where the spoke pool client
           // hasn't queried. This is because this function will usually be called
           // in production with block ranges that were validated by
-          // DataworkerblockRangesAreInvalidForSpokeClients
+          // DataworkerUtils.blockRangesAreInvalidForSpokeClients
           Math.min(destinationBlockRange[1], spokePoolClients[destinationChainId].latestBlockSearched),
           destinationChainId
         );
@@ -1279,7 +1293,7 @@ export class BundleDataClient {
           // We can assume that in production the block ranges passed into this function would never
           // contain blocks where the spoke pool client hasn't queried. This is because this function
           // will usually be called in production with block ranges that were validated by
-          // DataworkerblockRangesAreInvalidForSpokeClients.
+          // DataworkerUtils.blockRangesAreInvalidForSpokeClients.
           const startBlockForChain = Math.min(_startBlockForChain, spokePoolClient.latestBlockSearched);
           const endBlockForChain = Math.min(_endBlockForChain, spokePoolClient.latestBlockSearched);
           const [startTime, endTime] = [

package/src/providers/alchemy.ts

@@ -3,7 +3,7 @@ import { RPCTransport } from "./types";
 
 const MAINNET_CHAIN_IDs = Object.values(_MAINNET_CHAIN_IDs);
 
-// Chain-specific overrides for when the Alchemy endpoint does not match the canonical chain name.
+// Chain-specific overrides for when the endpoint name does not match the canonical chain name.
 const endpoints: { [chainId: string]: string } = {
   [CHAIN_IDs.ARBITRUM]: "arb",
   [CHAIN_IDs.ARBITRUM_SEPOLIA]: "arb-sepolia",
@@ -14,15 +14,15 @@ const endpoints: { [chainId: string]: string } = {
 };
 
 export function getURL(chainId: number, apiKey: string, transport: RPCTransport): string {
-  let host = endpoints[chainId] ?? PUBLIC_NETWORKS[chainId]?.name;
-  if (!host) {
+  let chain = endpoints[chainId] ?? PUBLIC_NETWORKS[chainId]?.name;
+  if (!chain) {
     throw new Error(`No known Alchemy provider for chainId ${chainId}`);
   }
 
   if (MAINNET_CHAIN_IDs.includes(chainId)) {
-    host = `${host}-mainnet`;
+    chain = `${chain}-mainnet`;
   }
-  host = host.toLowerCase().replace(" ", "-");
+  chain = chain.toLowerCase().replace(" ", "-");
 
-  return `${transport}://${host}.g.alchemy.com/v2/${apiKey}`;
+  return `${transport}://${chain}.g.alchemy.com/v2/${apiKey}`;
 }

package/src/providers/drpc.ts

@@ -0,0 +1,19 @@
+import { CHAIN_IDs, PUBLIC_NETWORKS } from "../constants";
+import { RPCTransport } from "./types";
+
+// Chain-specific overrides for when the endpoint name does not match the canonical chain name.
+const endpoints: { [chainId: string]: string } = {
+  [CHAIN_IDs.ARBITRUM]: "arbitrum",
+  [CHAIN_IDs.MAINNET]: "ethereum",
+};
+
+export function getURL(chainId: number, apiKey: string, transport: RPCTransport): string {
+  let chain = endpoints[chainId] ?? PUBLIC_NETWORKS[chainId]?.name;
+  if (!chain) {
+    throw new Error(`No known DRPC provider for chainId ${chainId}`);
+  }
+  chain = chain.toLowerCase().replace(" ", "-");
+  const rpcType = transport === "https" ? "rpc" : "ws";
+
+  return `${transport}://lb.drpc.org/og${rpcType}?network=${chain}&dkey=${apiKey}`;
+}

package/src/providers/infura.ts

@@ -3,21 +3,21 @@ import { RPCTransport } from "./types";
 
 const MAINNET_CHAIN_IDs = Object.values(_MAINNET_CHAIN_IDs);
 
-// Chain-specific overrides for when the Infura endpoint does not match the canonical chain name.
+// Chain-specific overrides for when the endpoint name does not match the canonical chain name.
 const endpoints: { [chainId: string]: string } = {
   [CHAIN_IDs.ARBITRUM]: "arbitrum",
 };
 
 export function getURL(chainId: number, apiKey: string, transport: RPCTransport): string {
-  let host = endpoints[chainId] ?? PUBLIC_NETWORKS[chainId]?.name;
-  if (!host) {
+  let chain = endpoints[chainId] ?? PUBLIC_NETWORKS[chainId]?.name;
+  if (!chain) {
     throw new Error(`No known Infura provider for chainId ${chainId}`);
   }
 
   if (chainId !== CHAIN_IDs.MAINNET && MAINNET_CHAIN_IDs.includes(chainId)) {
-    host = `${host}-mainnet`;
+    chain = `${chain}-mainnet`;
   }
-  host = host.toLowerCase().replace(" ", "-");
+  chain = chain.toLowerCase().replace(" ", "-");
 
-  return transport === "https" ? `https://${host}.infura.io/v3/${apiKey}` : `wss://${host}.infura.io/ws/v3/${apiKey}`;
+  return transport === "https" ? `https://${chain}.infura.io/v3/${apiKey}` : `wss://${chain}.infura.io/ws/v3/${apiKey}`;
 }

package/src/providers/types.ts

@@ -1,2 +1,2 @@
-export type RPCProvider = "INFURA" | "ALCHEMY";
+export type RPCProvider = "ALCHEMY" | "DRPC" | "INFURA" | "INFURA_DIN";
 export type RPCTransport = "https" | "wss";

package/src/providers/utils.ts

@@ -6,6 +6,7 @@ import { isDefined } from "../utils";
 import { RPCProvider, RPCTransport } from "./types";
 import * as alchemy from "./alchemy";
 import * as infura from "./infura";
+import * as drpc from "./drpc";
 
 /**
  * Infura DIN is identified separately to allow it to be configured explicitly.
@@ -14,6 +15,7 @@ const PROVIDERS = {
   ALCHEMY: alchemy.getURL,
   INFURA: infura.getURL,
   INFURA_DIN: infura.getURL,
+  DRPC: drpc.getURL,
 };
 
 /**
@@ -22,7 +24,7 @@ const PROVIDERS = {
  * @returns True if the provider string is a supported provider.
  */
 export function isSupportedProvider(provider: string): provider is RPCProvider {
-  return ["ALCHEMY", "INFURA", "INFURA_DIN"].includes(provider);
+  return ["ALCHEMY", "INFURA", "INFURA_DIN", "DRPC"].includes(provider);
 }
 
 /**