@across-protocol/sdk 4.3.59 → 4.3.61

package/src/arch/svm/SpokeUtils.ts

@@ -106,6 +106,16 @@ type ProtoFill = Omit<RelayData, "recipient" | "outputToken"> & {
   outputToken: SvmAddress;
 };
 
+type CCTPDepositAccounts = {
+  tokenMessenger: Address;
+  tokenMinter: Address;
+  localToken: Address;
+  cctpEventAuthority: Address;
+  remoteTokenMessenger: Address;
+  tokenMessengerMinterSenderAuthority: Address;
+  messageTransmitter: Address;
+};
+
 export function getSlot(provider: SVMProvider, commitment: Commitment, logger?: winston.Logger): Promise<bigint> {
   return _callGetSlotWithRetry(provider, commitment, logger);
 }
@@ -1265,7 +1275,9 @@ export const hasCCTPV1MessageBeenProcessed = async (
   solanaClient: SVMProvider,
   signer: KeyPairSigner,
   nonce: number,
-  sourceDomain: number
+  sourceDomain: number,
+  nRetries: number = 0,
+  maxRetries: number = 2
 ): Promise<boolean> => {
   let noncePda: Address;
   try {
@@ -1283,7 +1295,19 @@ export const hasCCTPV1MessageBeenProcessed = async (
     }
     return Boolean(buf[0]);
   };
-  return simulateAndDecode(solanaClient, isNonceUsedIx, signer, parserFunction);
+  // If the nonce PDA was found, we should be able to query the isNonceUsed parameter. If we can't then assume it is a transient RPC error
+  // and retry, and throw if the error persists.
+  try {
+    return await simulateAndDecode(solanaClient, isNonceUsedIx, signer, parserFunction);
+  } catch (e) {
+    if (nRetries < maxRetries) {
+      const delaySeconds = 2 ** nRetries + Math.random();
+      await delay(delaySeconds);
+
+      return hasCCTPV1MessageBeenProcessed(solanaClient, signer, nonce, sourceDomain, ++nRetries);
+    }
+    throw e;
+  }
 };
 
 /**
@@ -1347,6 +1371,73 @@ export async function getAccountMetasForTokenlessMessage(
   ];
 }
 
+/**
+ * Returns the required PDAs for a deposit message.
+ * @param hubChainId The chain ID of the corresponding Across hub.
+ * @param cctpSourceDomain The source chain (Solana) domain ID.
+ * @param tokenMessengerMinter The token messenger minter address.
+ * @param messageTransmitterAddress The message transmitter address.
+ */
+export async function getCCTPDepositAccounts(
+  hubChainId: number,
+  cctpSourceDomain: number,
+  tokenMessengerMinterAddress: Address,
+  messageTransmitterAddress: Address
+): Promise<CCTPDepositAccounts> {
+  const l2Usdc = SvmAddress.from(
+    TOKEN_SYMBOLS_MAP.USDC.addresses[chainIsProd(hubChainId) ? CHAIN_IDs.SOLANA : CHAIN_IDs.SOLANA_DEVNET]
+  );
+
+  const [
+    [tokenMessenger],
+    [tokenMinter],
+    [localToken],
+    [cctpEventAuthority],
+    [remoteTokenMessenger],
+    [tokenMessengerMinterSenderAuthority],
+    [messageTransmitter],
+  ] = await Promise.all([
+    getProgramDerivedAddress({
+      programAddress: tokenMessengerMinterAddress,
+      seeds: ["token_messenger"],
+    }),
+    getProgramDerivedAddress({
+      programAddress: tokenMessengerMinterAddress,
+      seeds: ["token_minter"],
+    }),
+    getProgramDerivedAddress({
+      programAddress: tokenMessengerMinterAddress,
+      seeds: ["local_token", bs58.decode(l2Usdc.toBase58())],
+    }),
+    getProgramDerivedAddress({
+      programAddress: tokenMessengerMinterAddress,
+      seeds: ["__event_authority"],
+    }),
+    getProgramDerivedAddress({
+      programAddress: tokenMessengerMinterAddress,
+      seeds: ["remote_token_messenger", String(cctpSourceDomain)],
+    }),
+    getProgramDerivedAddress({
+      programAddress: tokenMessengerMinterAddress,
+      seeds: ["sender_authority"],
+    }),
+    getProgramDerivedAddress({
+      programAddress: messageTransmitterAddress,
+      seeds: ["message_transmitter"],
+    }),
+  ]);
+
+  return {
+    tokenMessenger,
+    tokenMinter,
+    localToken,
+    cctpEventAuthority,
+    remoteTokenMessenger,
+    tokenMessengerMinterSenderAuthority,
+    messageTransmitter,
+  };
+}
+
 /**
  * Returns the account metas for a deposit message.
  * @param message The CCTP message.

package/src/constants.ts

@@ -88,6 +88,7 @@ export const STABLE_COIN_SYMBOLS = [
 
 export const CUSTOM_GAS_TOKENS = {
   [CHAIN_IDs.BSC]: "BNB",
+  [CHAIN_IDs.HYPEREVM]: "HYPE",
   [CHAIN_IDs.POLYGON]: "MATIC",
   [CHAIN_IDs.POLYGON_AMOY]: "MATIC",
   [CHAIN_IDs.ALEPH_ZERO]: "AZERO",

package/src/providers/alchemy.ts

@@ -13,6 +13,7 @@ const endpoints: { [chainId: number]: string } = {
   [CHAIN_IDs.OPTIMISM_SEPOLIA]: "opt-sepolia",
   [CHAIN_IDs.WORLD_CHAIN]: "worldchain",
   [CHAIN_IDs.BSC]: "bnb",
+  [CHAIN_IDs.HYPEREVM]: "hyperliquid",
 };
 
 export function getURL(chainId: number, apiKey: string, transport: RPCTransport): string {

package/src/providers/quicknode.ts

@@ -7,6 +7,7 @@ const SNOWFLAKES = {
   [CHAIN_IDs.POLYGON]: "matic",
   [CHAIN_IDs.OPTIMISM]: "optimism",
   [CHAIN_IDs.WORLD_CHAIN]: "worldchain-mainnet",
+  [CHAIN_IDs.HYPEREVM]: "hype-mainnet",
 };
 const SNOWFLAKE_CHAIN_IDs = Object.keys(SNOWFLAKES).map(Number);
 const MAINNET_CHAIN_IDs = Object.values(_MAINNET_CHAIN_IDs).map(Number);

package/src/utils/AddressUtils.ts

@@ -1,22 +1,46 @@
+import { isAddress } from "viem";
 import { providers, utils } from "ethers";
 import bs58 from "bs58";
 import { BigNumber, chainIsEvm, chainIsSvm } from "./";
 
+/**
+ * Verify whether an address' bytecode resembles an EIP-7702 delegation.
+ * @param code Bytecode for a given address.
+ * @returns True if the bytecode resembles an EIP-7702 delegation, otherwise false.
+ */
+export function is7702Delegate(code: string): boolean {
+  // Sample 7702 delegation bytecode: 0xef010063c0c19a282a1b52b07dd5a65b58948a07dae32b
+  return code.length === 48 && code.startsWith("0xef0100") && isAddress(`0x${code.slice(8)}`);
+}
+
 /**
  * Checks if a contract is deployed at the given address
  * @param address The ETH address to check
  * @param provider A valid Ethers.js provider
+ * @param ignore7702 A boolean to indicate whether EIP-7702 delegations should be considered as contract code.
  * @returns A boolean indicating if a contract is deployed at the given address or not (true = contract, false = no contract)
  */
-export async function isContractDeployedToAddress(address: string, provider: providers.Provider): Promise<boolean> {
+export async function isContractDeployedToAddress(
+  address: string,
+  provider: providers.Provider,
+  ignore7702 = false
+): Promise<boolean> {
   // A base case for if the address is null or malformed
-  if (!address || !utils.isAddress(address)) {
+  if (!address || !isAddress(address)) {
     return false;
   }
-  // Retrieve the code at the address
+
   const code = await provider.getCode(address);
-  // If the code is not empty, then there is a contract at this address
-  return code !== "0x";
+  if (code === "0x") {
+    return false;
+  }
+
+  // Ignore EIP-7702 delegations if ignore7702 was set.
+  if (ignore7702) {
+    return !is7702Delegate(code);
+  }
+
+  return true;
 }
 
 export function compareAddresses(addressA: string, addressB: string): 1 | -1 | 0 {
@@ -56,7 +80,7 @@ export function toEvmAddress(hexString: string): string {
 }
 
 export function isValidEvmAddress(address: string): boolean {
-  if (utils.isAddress(address)) {
+  if (isAddress(address)) {
     return true;
   }
   // We may throw an error here if hexZeroPadFails. This will happen if the address to pad is greater than 20 bytes long, indicating
@@ -65,7 +89,7 @@ export function isValidEvmAddress(address: string): boolean {
   // For both cases, this indicates that the address cannot be casted as a bytes20 EVM address, so we should return false.
   try {
     const evmAddress = utils.hexZeroPad(utils.hexStripZeros(address), 20);
-    return utils.isAddress(utils.getAddress(evmAddress));
+    return isAddress(utils.getAddress(evmAddress));
   } catch (_e) {
     return false;
   }

package/src/utils/Multicall.ts

@@ -30,6 +30,7 @@ const DETERMINISTIC_MULTICALL_CHAINS = [
   CHAIN_IDs.ALEPH_ZERO,
   CHAIN_IDs.ARBITRUM,
   CHAIN_IDs.BSC,
+  CHAIN_IDs.HYPEREVM,
   CHAIN_IDs.LINEA,
   CHAIN_IDs.MAINNET,
   CHAIN_IDs.POLYGON,

package/src/utils/NetworkUtils.ts

@@ -155,7 +155,7 @@ export function chainIsCCTPEnabled(chainId: number): boolean {
 export function chainIsOFTEnabled(chainId: number): boolean {
   // Add chainIds to oftEnabled as they are supported by the protocol.
   // This is backwards vs. CCTP logic because Across support for OFTs is limited vs. OFT deployments.
-  const oftEnabled = [CHAIN_IDs.ARBITRUM];
+  const oftEnabled = [CHAIN_IDs.ARBITRUM, CHAIN_IDs.POLYGON];
   return oftEnabled.includes(chainId) && PRODUCTION_NETWORKS[chainId]?.oftEid !== OFT_NO_EID;
 }