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

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

@@ -0,0 +1,28 @@
+import { CHAIN_IDs, MAINNET_CHAIN_IDs as _MAINNET_CHAIN_IDs, PUBLIC_NETWORKS } from "../constants";
+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.
+const endpoints: { [chainId: string]: string } = {
+  [CHAIN_IDs.ARBITRUM]: "arb",
+  [CHAIN_IDs.ARBITRUM_SEPOLIA]: "arb-sepolia",
+  [CHAIN_IDs.MAINNET]: "eth",
+  [CHAIN_IDs.SEPOLIA]: "eth-sepolia",
+  [CHAIN_IDs.OPTIMISM]: "opt",
+  [CHAIN_IDs.OPTIMISM_SEPOLIA]: "opt-sepolia",
+};
+
+export function getURL(chainId: number, apiKey: string, transport: RPCTransport): string {
+  let host = endpoints[chainId] ?? PUBLIC_NETWORKS[chainId]?.name;
+  if (!host) {
+    throw new Error(`No known Alchemy provider for chainId ${chainId}`);
+  }
+
+  if (MAINNET_CHAIN_IDs.includes(chainId)) {
+    host = `${host}-mainnet`;
+  }
+  host = host.toLowerCase().replace(" ", "-");
+
+  return `${transport}://${host}.g.alchemy.com/v2/${apiKey}`;
+}

package/src/providers/index.ts

@@ -2,4 +2,5 @@ export * from "./rateLimitedProvider";
 export * from "./cachedProvider";
 export * from "./retryProvider";
 export * from "./constants";
+export * from "./types";
 export * from "./utils";

package/src/providers/infura.ts

@@ -0,0 +1,23 @@
+import { CHAIN_IDs, MAINNET_CHAIN_IDs as _MAINNET_CHAIN_IDs, PUBLIC_NETWORKS } from "../constants";
+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.
+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) {
+    throw new Error(`No known Infura provider for chainId ${chainId}`);
+  }
+
+  if (chainId !== CHAIN_IDs.MAINNET && MAINNET_CHAIN_IDs.includes(chainId)) {
+    host = `${host}-mainnet`;
+  }
+  host = host.toLowerCase().replace(" ", "-");
+
+  return transport === "https" ? `https://${host}.infura.io/v3/${apiKey}` : `wss://${host}.infura.io/ws/v3/${apiKey}`;
+}

package/src/providers/types.ts

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

package/src/providers/utils.ts

@@ -1,8 +1,48 @@
 // The async/queue library has a task-based interface for building a concurrent queue.
-
+import assert from "assert";
 import { providers } from "ethers";
-import { isDefined } from "../utils";
 import { isEqual } from "lodash";
+import { isDefined } from "../utils";
+import { RPCProvider, RPCTransport } from "./types";
+import * as alchemy from "./alchemy";
+import * as infura from "./infura";
+
+/**
+ * Infura DIN is identified separately to allow it to be configured explicitly.
+ */
+const PROVIDERS = {
+  ALCHEMY: alchemy.getURL,
+  INFURA: infura.getURL,
+  INFURA_DIN: infura.getURL,
+};
+
+/**
+ * Type predicate for RPCProvider type.
+ * @param provider Provider string (ALCHEMY, INFURA, ...).
+ * @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);
+}
+
+/**
+ * Produce an RPC for a given RPC provider, chainId API key and transport.
+ * @param provider RPC provider identifier (ALCHEMY, INFURA, ...)
+ * @param chainId Chain ID to obtain a URL for.
+ * @param apiKey API key for provider.
+ * @param transport Optional transport specifier (HTTPS or WSS).
+ * @returns An RPC URL confirming to the specified inputs.
+ */
+export function getURL(
+  provider: RPCProvider,
+  chainId: number,
+  apiKey: string,
+  transport: RPCTransport = "https"
+): string {
+  const getURL = PROVIDERS[provider];
+  assert(getURL, `Unsupported RPC provider (${provider})`);
+  return getURL(chainId, apiKey, transport);
+}
 
 /**
  * Deletes keys from an object and returns new copy of object without ignored keys

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/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 };
+  }, {});
+}