@across-protocol/sdk 3.1.27 → 3.1.28

package/src/clients/BundleDataClient/utils/SuperstructUtils.ts

@@ -0,0 +1,132 @@
+import {
+  object,
+  number,
+  optional,
+  string,
+  array,
+  record,
+  coerce,
+  instance,
+  pattern,
+  boolean,
+  defaulted,
+} from "superstruct";
+import { BigNumber } from "ethers";
+
+const PositiveIntegerStringSS = pattern(string(), /\d+/);
+const Web3AddressSS = pattern(string(), /^0x[a-fA-F0-9]{40}$/);
+
+const BigNumberType = coerce(instance(BigNumber), string(), (value) => {
+  try {
+    // Attempt to convert the string to a BigNumber
+    return BigNumber.from(value);
+  } catch (error) {
+    // In case of any error during conversion, return the original value
+    // This will lead to a validation error, as the resulting value won't match the expected BigNumber type
+    return value;
+  }
+});
+
+const FillTypeSS = number();
+
+const V3RelayDataSS = {
+  inputToken: string(),
+  inputAmount: BigNumberType,
+  outputToken: string(),
+  outputAmount: BigNumberType,
+  fillDeadline: number(),
+  exclusiveRelayer: string(),
+  exclusivityDeadline: number(),
+  originChainId: number(),
+  depositor: string(),
+  recipient: string(),
+  depositId: number(),
+  message: string(),
+};
+
+const SortableEventSS = {
+  blockNumber: number(),
+  transactionIndex: number(),
+  logIndex: number(),
+  transactionHash: string(),
+};
+
+const V3DepositSS = {
+  fromLiteChain: defaulted(boolean(), false),
+  toLiteChain: defaulted(boolean(), false),
+  destinationChainId: number(),
+  quoteTimestamp: number(),
+  relayerFeePct: optional(BigNumberType),
+  speedUpSignature: optional(string()),
+  updatedRecipient: optional(string()),
+  updatedOutputAmount: optional(BigNumberType),
+  updatedMessage: optional(string()),
+};
+
+const _V3DepositWithBlockSS = {
+  quoteBlockNumber: number(),
+  ...V3DepositSS,
+  ...SortableEventSS,
+  ...V3RelayDataSS,
+};
+
+const V3DepositWithBlockSS = object(_V3DepositWithBlockSS);
+const V3DepositWithBlockLpFeeSS = object({
+  ..._V3DepositWithBlockSS,
+  lpFeePct: BigNumberType,
+});
+
+const V3RelayExecutionEventInfoSS = object({
+  updatedOutputAmount: BigNumberType,
+  fillType: FillTypeSS,
+  updatedRecipient: string(),
+  updatedMessage: string(),
+});
+
+const V3FillSS = {
+  ...V3RelayDataSS,
+  destinationChainId: number(),
+  relayer: string(),
+  repaymentChainId: number(),
+  relayExecutionInfo: V3RelayExecutionEventInfoSS,
+  quoteTimestamp: number(),
+};
+
+const V3FillWithBlockSS = {
+  ...SortableEventSS,
+  ...V3FillSS,
+};
+
+const BundleFillV3SS = object({
+  ...V3FillWithBlockSS,
+  lpFeePct: BigNumberType,
+});
+
+const nestedV3DepositRecordSS = record(PositiveIntegerStringSS, record(Web3AddressSS, array(V3DepositWithBlockSS)));
+const nestedV3DepositRecordWithLpFeePctSS = record(
+  PositiveIntegerStringSS,
+  record(Web3AddressSS, array(V3DepositWithBlockLpFeeSS))
+);
+
+const nestedV3BundleFillsSS = record(
+  // Must be a chainId
+  PositiveIntegerStringSS,
+  record(
+    Web3AddressSS,
+    object({
+      fills: array(BundleFillV3SS),
+      refunds: record(string(), BigNumberType),
+      totalRefundAmount: BigNumberType,
+      realizedLpFees: BigNumberType,
+    })
+  )
+);
+
+export const BundleDataSS = object({
+  bundleBlockRanges: array(array(number())),
+  bundleDepositsV3: nestedV3DepositRecordSS,
+  expiredDepositsToRefundV3: nestedV3DepositRecordSS,
+  unexecutableSlowFills: nestedV3DepositRecordWithLpFeePctSS,
+  bundleSlowFillsV3: nestedV3DepositRecordWithLpFeePctSS,
+  bundleFillsV3: nestedV3BundleFillsSS,
+});

package/src/clients/BundleDataClient/utils/index.ts

@@ -0,0 +1,6 @@
+export * from "./shims";
+export * from "./FillUtils";
+export * from "./DataworkerUtils";
+export * from "./PoolRebalanceUtils";
+export * from "./SuperstructUtils";
+export * from "./MerkleTreeUtils";

package/src/clients/BundleDataClient/utils/shims.ts

@@ -0,0 +1,10 @@
+import { RelayData, Deposit, DepositWithBlock, SpeedUp, Fill, FillWithBlock, SlowFillLeaf } from "../../../interfaces";
+
+// V3 shims (to be removed later)
+export type V3RelayData = RelayData;
+export type V3Deposit = Deposit;
+export type V3DepositWithBlock = DepositWithBlock;
+export type V3SpeedUp = SpeedUp;
+export type V3Fill = Fill;
+export type V3FillWithBlock = FillWithBlock;
+export type V3SlowFillLeaf = SlowFillLeaf;

package/src/clients/index.ts

@@ -6,4 +6,5 @@ export {
 } from "./AcrossConfigStoreClient";
 export { HubPoolClient, LpFeeRequest } from "./HubPoolClient";
 export { SpokePoolClient, SpokePoolUpdate } from "./SpokePoolClient";
+export * as BundleDataClient from "./BundleDataClient";
 export * as mocks from "./mocks";

package/src/interfaces/BundleData.ts

@@ -0,0 +1,68 @@
+import { BigNumber, Signer } from "ethers";
+import { DepositWithBlock, FillWithBlock, Refund } from "./SpokePool";
+import { HubPoolClient } from "../clients/HubPoolClient";
+import { AcrossConfigStoreClient } from "../clients";
+import { ArweaveClient } from "../caching";
+
+export type ExpiredDepositsToRefundV3 = {
+  [originChainId: number]: {
+    [originToken: string]: DepositWithBlock[];
+  };
+};
+
+export type BundleDepositsV3 = {
+  [originChainId: number]: {
+    [originToken: string]: DepositWithBlock[];
+  };
+};
+
+export interface BundleFillV3 extends FillWithBlock {
+  lpFeePct: BigNumber;
+}
+
+export type BundleFillsV3 = {
+  [repaymentChainId: number]: {
+    [repaymentToken: string]: {
+      fills: BundleFillV3[];
+      refunds: Refund;
+      totalRefundAmount: BigNumber;
+      realizedLpFees: BigNumber;
+    };
+  };
+};
+
+export type BundleExcessSlowFills = {
+  [destinationChainId: number]: {
+    [destinationToken: string]: (DepositWithBlock & { lpFeePct: BigNumber })[];
+  };
+};
+export type BundleSlowFills = {
+  [destinationChainId: number]: {
+    [destinationToken: string]: (DepositWithBlock & { lpFeePct: BigNumber })[];
+  };
+};
+
+export type LoadDataReturnValue = {
+  bundleDepositsV3: BundleDepositsV3;
+  expiredDepositsToRefundV3: ExpiredDepositsToRefundV3;
+  bundleFillsV3: BundleFillsV3;
+  unexecutableSlowFills: BundleExcessSlowFills;
+  bundleSlowFillsV3: BundleSlowFills;
+};
+
+export type BundleData = LoadDataReturnValue & {
+  bundleBlockRanges: number[][];
+};
+
+export interface Clients {
+  hubPoolClient: HubPoolClient;
+  configStoreClient: AcrossConfigStoreClient;
+  hubSigner?: Signer;
+  arweaveClient: ArweaveClient;
+}
+
+export type CombinedRefunds = {
+  [repaymentChainId: number]: {
+    [repaymentToken: string]: Refund;
+  };
+};

package/src/interfaces/index.ts

@@ -6,3 +6,4 @@ export * from "./Bridge";
 export * from "./Error";
 export * from "./TypedData";
 export * from "./CachingMechanism";
+export * from "./BundleData";

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);
 }
 
 /**

package/src/utils/AddressUtils.ts

@@ -1,4 +1,4 @@
-import { providers, utils } from "ethers";
+import { BigNumber, providers, utils } from "ethers";
 
 /**
  * Checks if a contract is deployed at the given address
@@ -17,6 +17,20 @@ export async function isContractDeployedToAddress(address: string, provider: pro
   return code !== "0x";
 }
 
+export function compareAddresses(addressA: string, addressB: string): 1 | -1 | 0 {
+  // Convert address strings to BigNumbers and then sort numerical value of the BigNumber, which sorts the addresses
+  // effectively by their hex value.
+  const bnAddressA = BigNumber.from(addressA);
+  const bnAddressB = BigNumber.from(addressB);
+  if (bnAddressA.gt(bnAddressB)) {
+    return 1;
+  } else if (bnAddressA.lt(bnAddressB)) {
+    return -1;
+  } else {
+    return 0;
+  }
+}
+
 export function compareAddressesSimple(addressA?: string, addressB?: string): boolean {
   if (addressA === undefined || addressB === undefined) {
     return false;

package/src/utils/ContractUtils.ts

@@ -0,0 +1,8 @@
+import * as typechain from "@across-protocol/contracts/dist/typechain"; // Import the typechain module
+
+export function getParamType(contractName: string, functionName: string, paramName: string): string {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const artifact = (typechain as any)[`${[contractName]}__factory`];
+  const fragment = artifact.abi.find((fragment: { name: string }) => fragment.name === functionName);
+  return fragment?.inputs.find((input: { name: string }) => input.name === paramName) || "";
+}

package/src/utils/Multicall.ts

@@ -1,5 +1,6 @@
 import { BigNumber, Contract, providers, Signer, utils as ethersUtils } from "ethers";
-import { getABI } from "./abi";
+import { CHAIN_IDs } from "@across-protocol/constants";
+import { Multicall3, Multicall3__factory } from "./abi/typechain";
 
 type Provider = providers.Provider;
 type BlockTag = providers.BlockTag;
@@ -12,41 +13,48 @@ export type Call3 = {
   args?: any[];
 };
 
-// Multicall3 Constants:
-export const multicall3Addresses: Record<number, string> = {
-  1: "0xcA11bde05977b3631167028862bE2a173976CA11",
-  10: "0xcA11bde05977b3631167028862bE2a173976CA11",
-  137: "0xcA11bde05977b3631167028862bE2a173976CA11",
-  324: "0xF9cda624FBC7e059355ce98a31693d299FACd963",
-  8453: "0xcA11bde05977b3631167028862bE2a173976CA11",
-  34443: "0xcA11bde05977b3631167028862bE2a173976CA11",
-  42161: "0xcA11bde05977b3631167028862bE2a173976CA11",
-  59144: "0xcA11bde05977b3631167028862bE2a173976CA11",
-  534352: "0xcA11bde05977b3631167028862bE2a173976CA11",
-  // Testnets
-  5: "0xcA11bde05977b3631167028862bE2a173976CA11",
-  300: "0xF9cda624FBC7e059355ce98a31693d299FACd963",
-  59140: "0xcA11bde05977b3631167028862bE2a173976CA11",
-  59141: "0xcA11bde05977b3631167028862bE2a173976CA11",
-  80002: "0xcA11bde05977b3631167028862bE2a173976CA11",
-  84531: "0xcA11bde05977b3631167028862bE2a173976CA11",
-  84532: "0xcA11bde05977b3631167028862bE2a173976CA11",
-  421613: "0xcA11bde05977b3631167028862bE2a173976CA11",
-  534351: "0xcA11bde05977b3631167028862bE2a173976CA11",
-  11155111: "0xcA11bde05977b3631167028862bE2a173976CA11",
-  11155420: "0xcA11bde05977b3631167028862bE2a173976CA11",
+const DETERMINISTIC_MULTICALL_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+
+const NON_DETERMINISTIC_MULTICALL_ADDRESSES = {
+  [CHAIN_IDs.ZK_SYNC]: "0xF9cda624FBC7e059355ce98a31693d299FACd963",
 };
 
-export async function getMulticall3(
-  chainId: number,
-  signerOrProvider?: Signer | Provider
-): Promise<Contract | undefined> {
-  const address = multicall3Addresses[chainId];
+const DETERMINISTIC_MULTICALL_CHAINS = [
+  CHAIN_IDs.ARBITRUM,
+  CHAIN_IDs.BASE,
+  CHAIN_IDs.BLAST,
+  CHAIN_IDs.BOBA,
+  CHAIN_IDs.LINEA,
+  CHAIN_IDs.LISK,
+  CHAIN_IDs.MAINNET,
+  CHAIN_IDs.MODE,
+  CHAIN_IDs.OPTIMISM,
+  CHAIN_IDs.POLYGON,
+  CHAIN_IDs.REDSTONE,
+  CHAIN_IDs.SCROLL,
+  CHAIN_IDs.ZORA,
+  // Testnet:
+  CHAIN_IDs.BASE_SEPOLIA,
+  CHAIN_IDs.BLAST_SEPOLIA,
+  CHAIN_IDs.POLYGON_AMOY,
+  CHAIN_IDs.SCROLL_SEPOLIA,
+  CHAIN_IDs.SEPOLIA,
+];
+
+export function getMulticallAddress(chainId: number): string | undefined {
+  if (DETERMINISTIC_MULTICALL_CHAINS.includes(chainId)) {
+    return DETERMINISTIC_MULTICALL_ADDRESS;
+  }
+  return NON_DETERMINISTIC_MULTICALL_ADDRESSES[chainId];
+}
+
+export function getMulticall3(chainId: number, signerOrProvider: Signer | Provider): Multicall3 | undefined {
+  const address = getMulticallAddress(chainId);
   if (!address) {
     return undefined;
   }
 
-  return new Contract(address, await getABI("Multicall3"), signerOrProvider);
+  return Multicall3__factory.connect(address, signerOrProvider);
 }
 
 export async function aggregate(multicall3: Contract, calls: Call3[], blockTag?: BlockTag): Promise<Result[]> {

package/src/utils/ObjectUtils.ts

@@ -76,3 +76,26 @@ export function groupObjectCountsByProp(objects: any[], getProp: (obj: any) => s
 export function filterFalsyKeys(obj: Record<string | number, unknown>): Record<string | number, unknown> {
   return Object.fromEntries(Object.entries(obj).filter(([, v]) => v));
 }
+
+export function count2DDictionaryValues(dictionary: { [key: string]: { [key2: string]: any[] } }): {
+  [key: string]: { [key2: string]: number };
+} {
+  return Object.entries(dictionary).reduce((output, [key, innerDict]) => {
+    const innerDictOutput = Object.entries(innerDict).reduce((innerOutput, [key2, vals]) => {
+      return { ...innerOutput, [key2]: vals.length };
+    }, {});
+    return { ...output, [key]: innerDictOutput };
+  }, {});
+}
+
+export function count3DDictionaryValues(
+  dictionary: { [key: string]: { [key2: string]: any } },
+  innerPropName: string
+): { [key: string]: { [key2: string]: number } } {
+  return Object.entries(dictionary).reduce((output, [key, innerDict]) => {
+    const innerDictOutput = Object.entries(innerDict).reduce((innerOutput, [key2, vals]) => {
+      return { ...innerOutput, [key2]: vals[innerPropName].length };
+    }, {});
+    return { ...output, [key]: innerDictOutput };
+  }, {});
+}

package/src/utils/abi/contracts/index.ts

@@ -0,0 +1 @@
+export { default as Multicall3Abi } from "./Multicall3.json";