@across-protocol/sdk 4.3.20 → 4.3.23

package/dist/types/utils/TokenUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TokenUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/TokenUtils.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"TokenUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/TokenUtils.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@across-protocol/sdk",
   "author": "UMA Team",
-  "version": "4.3.20",
+  "version": "4.3.23",
   "license": "AGPL-3.0",
   "homepage": "https://docs.across.to/reference/sdk",
   "files": [

package/src/arch/svm/SpokeUtils.ts

@@ -1,18 +1,21 @@
 import { MessageTransmitterClient, SvmSpokeClient, TokenMessengerMinterClient } from "@across-protocol/contracts";
 import { decodeFillStatusAccount, fetchState } from "@across-protocol/contracts/dist/src/svm/clients/SvmSpoke";
-import { hashNonEmptyMessage } from "@across-protocol/contracts/dist/src/svm/web3-v1";
+import { decodeMessageHeader, hashNonEmptyMessage } from "@across-protocol/contracts/dist/src/svm/web3-v1";
 import { intToU8Array32 } from "@across-protocol/contracts/dist/src/svm/web3-v1/conversionUtils";
 import { SYSTEM_PROGRAM_ADDRESS } from "@solana-program/system";
 import {
   ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+  Mint,
   TOKEN_PROGRAM_ADDRESS,
   fetchMint,
   getApproveCheckedInstruction,
   getCreateAssociatedTokenIdempotentInstruction,
 } from "@solana-program/token";
 import {
+  Account,
   AccountRole,
   Address,
+  FetchAccountConfig,
   IAccountMeta,
   KeyPairSigner,
   ReadonlyUint8Array,
@@ -61,11 +64,17 @@ import {
   simulateAndDecode,
   toAddress,
   unwrapEventData,
+  getRootBundlePda,
 } from "./";
 import { SvmCpiEventsClient } from "./eventsClient";
 import { SVM_NO_BLOCK_AT_SLOT, isSolanaError } from "./provider";
 import { AttestedCCTPMessage, SVMEventNames, SVMProvider } from "./types";
-import { getNearestSlotTime } from "./utils";
+import {
+  getEmergencyDeleteRootBundleRootBundleId,
+  getNearestSlotTime,
+  isEmergencyDeleteRootBundleMessageBody,
+  isRelayRootBundleMessageBody,
+} from "./utils";
 
 /**
  * @note: Average Solana slot duration is about 400-500ms. We can be conservative
@@ -555,7 +564,7 @@ export async function getFillRelayTx(
   ]);
 
   const mint = toAddress(outputToken);
-  const mintInfo = await fetchMint(solanaClient, mint);
+  const mintInfo = await getMintInfo(solanaClient, mint);
 
   const [recipientAta, relayerAta, fillStatus, eventAuthority] = await Promise.all([
     getAssociatedTokenAddress(recipient, outputToken, mintInfo.programAddress),
@@ -618,7 +627,7 @@ export const createFillInstruction = async (
   tokenDecimals: number,
   createRecipientAtaIfNeeded: boolean = true
 ) => {
-  const mintInfo = await fetchMint(solanaClient, fillInput.mint);
+  const mintInfo = await getMintInfo(solanaClient, fillInput.mint);
   const approveIx = getApproveCheckedInstruction(
     {
       source: fillInput.relayerTokenAccount,
@@ -679,7 +688,7 @@ export const createDepositInstruction = async (
       systemProgram: depositInput.systemProgram,
       tokenProgram: depositInput.tokenProgram,
     });
-  const mintInfo = await fetchMint(solanaClient, depositInput.mint);
+  const mintInfo = await getMintInfo(solanaClient, depositInput.mint);
   const approveIx = getApproveCheckedInstruction(
     {
       source: depositInput.depositorTokenAccount,
@@ -1112,15 +1121,59 @@ export const hasCCTPV1MessageBeenProcessed = async (
  * Returns the account metas for a tokenless message.
  * @returns The account metas for a tokenless message.
  */
-export async function getAccountMetasForTokenlessMessage(): Promise<IAccountMeta<string>[]> {
-  const statePda = await getStatePda(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS);
-  return [
+export async function getAccountMetasForTokenlessMessage(
+  solanaClient: SVMProvider,
+  signer: KeyPairSigner,
+  messageBytes: string
+): Promise<IAccountMeta<string>[]> {
+  const messageHeader = decodeMessageHeader(Buffer.from(messageBytes, "hex"));
+  const programAddress = SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS;
+  const statePda = await getStatePda(programAddress);
+  const selfAuthority = await getSelfAuthority();
+  const eventAuthority = await getEventAuthority(programAddress);
+
+  const base: IAccountMeta<string>[] = [
     { address: statePda, role: AccountRole.READONLY },
-    { address: await getSelfAuthority(), role: AccountRole.READONLY },
-    { address: SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS, role: AccountRole.READONLY },
+    { address: selfAuthority, role: AccountRole.READONLY },
+    { address: programAddress, role: AccountRole.READONLY },
+  ];
+
+  if (isRelayRootBundleMessageBody(messageHeader.messageBody)) {
+    const {
+      data: { rootBundleId },
+    } = await SvmSpokeClient.fetchState(solanaClient, statePda);
+    const rootBundle = await getRootBundlePda(programAddress, rootBundleId);
+
+    return [
+      ...base,
+      { address: signer.address, role: AccountRole.WRITABLE },
+      { address: statePda, role: AccountRole.WRITABLE },
+      { address: rootBundle, role: AccountRole.WRITABLE },
+      { address: SYSTEM_PROGRAM_ADDRESS, role: AccountRole.READONLY },
+      { address: eventAuthority, role: AccountRole.READONLY },
+      { address: programAddress, role: AccountRole.READONLY },
+    ];
+  }
+
+  if (isEmergencyDeleteRootBundleMessageBody(messageHeader.messageBody)) {
+    const rootBundleId = getEmergencyDeleteRootBundleRootBundleId(messageHeader.messageBody);
+    const rootBundle = await getRootBundlePda(programAddress, rootBundleId);
+
+    return [
+      ...base,
+      { address: signer.address, role: AccountRole.READONLY },
+      { address: statePda, role: AccountRole.READONLY },
+      { address: rootBundle, role: AccountRole.WRITABLE },
+      { address: eventAuthority, role: AccountRole.READONLY },
+      { address: programAddress, role: AccountRole.READONLY },
+    ];
+  }
+
+  return [
+    ...base,
     { address: statePda, role: AccountRole.WRITABLE },
-    { address: await getEventAuthority(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS), role: AccountRole.READONLY },
-    { address: SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS, role: AccountRole.READONLY },
+    { address: eventAuthority, role: AccountRole.READONLY },
+    { address: programAddress, role: AccountRole.READONLY },
   ];
 }
 
@@ -1246,7 +1299,7 @@ export async function getCCTPV1ReceiveMessageTx(
         hubChainId,
         TokenMessengerMinterClient.TOKEN_MESSENGER_MINTER_PROGRAM_ADDRESS
       )
-    : await getAccountMetasForTokenlessMessage();
+    : await getAccountMetasForTokenlessMessage(solanaClient, signer, message.messageBytes);
 
   const messageBytes = message.messageBytes.startsWith("0x")
     ? Buffer.from(message.messageBytes.slice(2), "hex")
@@ -1260,7 +1313,7 @@ export async function getCCTPV1ReceiveMessageTx(
     messageTransmitter: messageTransmitterPda,
     eventAuthority: eventAuthorityPda,
     usedNonces,
-    receiver: SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS,
+    receiver: cctpMessageReceiver,
     systemProgram: SYSTEM_PROGRAM_ADDRESS,
     message: messageBytes,
     attestation: Buffer.from(message.attestation.slice(2), "hex"),
@@ -1315,3 +1368,11 @@ export function finalizeCCTPV1Messages(
     return signature;
   });
 }
+
+export async function getMintInfo(
+  solanaClient: SVMProvider,
+  mint: Address<string>,
+  config?: FetchAccountConfig
+): Promise<Account<Mint, string>> {
+  return await fetchMint(solanaClient, mint, config);
+}

package/src/arch/svm/utils.ts

@@ -1,9 +1,7 @@
-import assert from "assert";
-import { MessageTransmitterClient, SvmSpokeClient } from "@across-protocol/contracts";
+import { MessageTransmitterClient, SpokePool__factory, SvmSpokeClient } from "@across-protocol/contracts";
 import { BN, BorshEventCoder, Idl } from "@coral-xyz/anchor";
 import {
   Address,
-  type Commitment,
   IInstruction,
   KeyPairSigner,
   address,
@@ -19,14 +17,16 @@ import {
   setTransactionMessageFeePayerSigner,
   setTransactionMessageLifetimeUsingBlockhash,
   signTransactionMessageWithSigners,
+  type Commitment,
   type TransactionSigner,
 } from "@solana/kit";
+import assert from "assert";
 import bs58 from "bs58";
 import { ethers } from "ethers";
 import { FillType, RelayData } from "../../interfaces";
-import { BigNumber, Address as SdkAddress, getRelayDataHash, isDefined, isUint8Array } from "../../utils";
-import { AttestedCCTPMessage, EventName, SVMEventNames, SVMProvider } from "./types";
+import { BigNumber, Address as SdkAddress, biMin, getRelayDataHash, isDefined, isUint8Array } from "../../utils";
 import { getTimestampForSlot } from "./SpokeUtils";
+import { AttestedCCTPMessage, EventName, SVMEventNames, SVMProvider } from "./types";
 
 export { isSolanaError } from "@solana/kit";
 
@@ -90,11 +90,11 @@ export async function getLatestFinalizedSlotWithBlock(
   maxSlot: bigint,
   maxLookback = 1000
 ): Promise<number> {
-  const { slot: finalizedSlot } = await getNearestSlotTime(provider, { commitment: "finalized" });
-  const endSlot = Math.min(Number(maxSlot), Number(finalizedSlot));
   const opts = { maxSupportedTransactionVersion: 0, transactionDetails: "none", rewards: false } as const;
+  const { slot: finalizedSlot } = await getNearestSlotTime(provider, { commitment: "finalized" });
+  const endSlot = biMin(maxSlot, finalizedSlot);
 
-  let slot = BigInt(endSlot);
+  let slot = endSlot;
   do {
     const block = await provider.getBlock(slot, opts).send();
     if (isDefined(block) && [block.blockHeight, block.blockTime].every(isDefined)) {
@@ -472,6 +472,41 @@ export function isDepositForBurnEvent(event: AttestedCCTPMessage): boolean {
   return event.type === "transfer";
 }
 
+/**
+ * True if `body` encodes a `relayRootBundle(bytes32,bytes32)` call.
+ */
+export const isRelayRootBundleMessageBody = (body: Buffer): boolean => {
+  if (body.length < 4) return false;
+
+  const spokePoolInterface = new ethers.utils.Interface(SpokePool__factory.abi);
+  const relayRootBundleSelector = spokePoolInterface.getSighash("relayRootBundle");
+
+  return body.slice(0, 4).equals(Buffer.from(relayRootBundleSelector.slice(2), "hex"));
+};
+
+/**
+ * True if `body` encodes a `emergencyDeleteRootBundle(uint32)` call.
+ */
+export const isEmergencyDeleteRootBundleMessageBody = (body: Buffer): boolean => {
+  if (body.length < 4) return false;
+
+  const spokePoolInterface = new ethers.utils.Interface(SpokePool__factory.abi);
+  const emergencyDeleteRootBundleSelector = spokePoolInterface.getSighash("emergencyDeleteRootBundle");
+
+  return body.slice(0, 4).equals(Buffer.from(emergencyDeleteRootBundleSelector.slice(2), "hex"));
+};
+
+/**
+ * Decodes the root bundle ID from an emergency delete root bundle message body.
+ * @param body The message body.
+ * @returns The root bundle ID.
+ */
+export const getEmergencyDeleteRootBundleRootBundleId = (body: Buffer): number => {
+  const spokePoolInterface = new ethers.utils.Interface(SpokePool__factory.abi);
+  const result = spokePoolInterface.decodeFunctionData("emergencyDeleteRootBundle", body);
+  return result.rootBundleId.toNumber();
+};
+
 /**
  * Convert a bigint (0 ≤ n < 2^256) to a 32-byte Uint8Array (big-endian).
  * @param n The bigint to convert.

package/src/caching/Arweave/ArweaveClient.ts

@@ -4,7 +4,7 @@ import axios from "axios";
 import { Struct, create } from "superstruct";
 import winston from "winston";
 import { ARWEAVE_TAG_APP_NAME, ARWEAVE_TAG_APP_VERSION, DEFAULT_ARWEAVE_STORAGE_ADDRESS } from "../../constants";
-import { BigNumber, isDefined, jsonReplacerWithBigNumbers, toBN } from "../../utils";
+import { BigNumber, delay, isDefined, jsonReplacerWithBigNumbers, toBN } from "../../utils";
 
 export class ArweaveClient {
   private client: Arweave;
@@ -15,7 +15,9 @@ export class ArweaveClient {
     private logger: winston.Logger,
     gatewayURL = "arweave.net",
     protocol = "https",
-    port = 443
+    port = 443,
+    private readonly retries = 2,
+    private readonly retryDelaySeconds = 1
   ) {
     this.gatewayUrl = `${protocol}://${gatewayURL}:${port}`;
     this.client = new Arweave({
@@ -30,6 +32,12 @@ export class ArweaveClient {
       message: "Arweave client initialized",
       gateway: this.gatewayUrl,
     });
+    if (this.retries < 0) {
+      throw new Error(`retries cannot be < 0 and must be an integer. Currently set to ${this.retries}`);
+    }
+    if (this.retryDelaySeconds < 0) {
+      throw new Error(`delay cannot be < 0. Currently set to ${this.retryDelaySeconds}`);
+    }
   }
 
   /**
@@ -225,21 +233,48 @@ export class ArweaveClient {
     return this.client.wallets.jwkToAddress(this.arweaveJWT);
   }
 
+  private async _retryRequest<T>(request: () => Promise<T>, retryCount: number): Promise<T> {
+    try {
+      return request();
+    } catch (e) {
+      if (retryCount < this.retries) {
+        // Implement a slightly aggressive exponential backoff to account for fierce parallelism.
+        const baseDelay = this.retryDelaySeconds * Math.pow(2, retryCount); // ms; attempt = [0, 1, 2, ...]
+        const delayS = baseDelay + baseDelay * Math.random();
+        this.logger.debug({
+          at: "ArweaveClient:getBalance",
+          message: `Arweave request failed, retrying after waiting ${delayS} seconds: ${e}`,
+          retryCount,
+        });
+        await delay(delayS);
+        return this._retryRequest(request, retryCount + 1);
+      } else {
+        throw e;
+      }
+    }
+  }
+
   /**
    * The balance of the signer
    * @returns The balance of the signer in winston units
    */
   async getBalance(): Promise<BigNumber> {
     const address = await this.getAddress();
-    const balanceInFloat = await this.client.wallets.getBalance(address);
-    // Sometimes the balance is returned in scientific notation, so we need to
-    // convert it to a BigNumber
-    if (balanceInFloat.includes("e")) {
-      const [balance, exponent] = balanceInFloat.split("e");
-      const resultingBN = BigNumber.from(balance).mul(toBN(10).pow(exponent.replace("+", "")));
-      return BigNumber.from(resultingBN.toString());
-    } else {
-      return BigNumber.from(balanceInFloat);
-    }
+    const request = async () => {
+      const balanceInFloat = await this.client.wallets.getBalance(address);
+      // @dev The reason we add in the BN.from into this retry loop is because the client.getBalance call
+      // does not correctly throw an error if the request fails, instead it will return the error string as the
+      // balanceInFloat.
+      // Sometimes the balance is returned in scientific notation, so we need to
+      // convert it to a BigNumber
+      if (balanceInFloat.includes("e")) {
+        const [balance, exponent] = balanceInFloat.split("e");
+        const resultingBN = BigNumber.from(balance).mul(toBN(10).pow(exponent.replace("+", "")));
+        return BigNumber.from(resultingBN.toString());
+      } else {
+        return BigNumber.from(balanceInFloat);
+      }
+    };
+    return await this._retryRequest(request, 0);
   }
 }

package/src/gasPriceOracle/adapters/ethereum.ts

@@ -1,6 +1,6 @@
 import assert from "assert";
 import { providers } from "ethers";
-import { BigNumber, bnZero, fixedPointAdjustment, getNetworkName, parseUnits } from "../../utils";
+import { BigNumber, bnZero, fixedPointAdjustment, getNetworkName } from "../../utils";
 import { EvmGasPriceEstimate } from "../types";
 import { gasPriceError } from "../util";
 import { GasPriceEstimateOptions } from "../oracle";
@@ -37,11 +37,7 @@ export async function eip1559Raw(
   const maxPriorityFeePerGas = BigNumber.from(_maxPriorityFeePerGas);
   assert(BigNumber.isBigNumber(baseFeePerGas), `No baseFeePerGas received on ${getNetworkName(chainId)}`);
 
-  let scaledPriorityFee = maxPriorityFeePerGas.mul(priorityFeeMultiplier).div(fixedPointAdjustment);
-  const flooredPriorityFeePerGas = parseUnits(process.env[`MIN_PRIORITY_FEE_PER_GAS_${chainId}`] || "0", 9);
-  if (scaledPriorityFee.lt(flooredPriorityFeePerGas)) {
-    scaledPriorityFee = BigNumber.from(flooredPriorityFeePerGas);
-  }
+  const scaledPriorityFee = maxPriorityFeePerGas.mul(priorityFeeMultiplier).div(fixedPointAdjustment);
   const scaledBaseFee = baseFeePerGas.mul(baseFeeMultiplier).div(fixedPointAdjustment);
   return {
     maxFeePerGas: scaledPriorityFee.add(scaledBaseFee),

package/src/gasPriceOracle/adapters/solana.ts

@@ -1,5 +1,5 @@
 import { SVMProvider } from "../../arch/svm";
-import { toBN, dedupArray, parseUnits } from "../../utils";
+import { toBN, dedupArray } from "../../utils";
 import { SvmGasPriceEstimate } from "../types";
 import { GasPriceEstimateOptions } from "../oracle";
 import { CompilableTransactionMessage, TransactionMessageBytesBase64, compileTransaction } from "@solana/kit";
@@ -32,14 +32,9 @@ export async function messageFee(provider: SVMProvider, opts: GasPriceEstimateOp
     .filter((fee) => fee > 0);
   const totalPrioritizationFees = nonzeroPrioritizationFees.reduce((acc, fee) => acc + fee, BigInt(0));
 
-  // Optionally impose a minimum priority fee, denoted in microLamports/computeUnit.
-  const flooredPriorityFeePerGas = parseUnits(process.env[`MIN_PRIORITY_FEE_PER_GAS_${opts.chainId}`] || "0", 6);
-  let microLamportsPerComputeUnit = toBN(
+  const microLamportsPerComputeUnit = toBN(
     totalPrioritizationFees / BigInt(Math.max(nonzeroPrioritizationFees.length, 1))
   );
-  if (microLamportsPerComputeUnit.lt(flooredPriorityFeePerGas)) {
-    microLamportsPerComputeUnit = flooredPriorityFeePerGas;
-  }
   return {
     baseFee: toBN(baseFeeResponse!.value!),
     microLamportsPerComputeUnit,

package/src/providers/utils.ts

@@ -96,14 +96,17 @@ const IGNORED_FIELDS = {
   // 2023-08-31 Added blockHash because of upstream zkSync provider disagreements. Consider removing later.
   // 2024-05-07 Added l1BatchNumber and logType due to Alchemy. Consider removing later.
   // 2024-07-11 Added blockTimestamp after zkSync rolled out a new node release.
+  // 2025-07-24 Added additional fields returned by Chainstack on (at least) Polygon.
   eth_getBlockByNumber: [
     "miner", // polygon (sometimes)
     "l1BatchNumber", // zkSync
     "l1BatchTimestamp", // zkSync
+    "requestsHash", // Chainstack (Polygon)
     "size", // Alchemy/Arbitrum (temporary)
     "totalDifficulty", // Quicknode/Alchemy (sometimes)
     "logsBloom", // zkSync (third-party providers return 0x0..0)
     "transactions", // Polygon yParity field in transactions[]
+    "withdrawals", // Chainstack (Polygon)
   ],
   eth_getLogs: ["blockTimestamp", "transactionLogIndex", "l1BatchNumber", "logType"],
 };

package/src/utils/BigNumberUtils.ts

@@ -19,6 +19,12 @@ export const bnOne = BigNumber.from("1");
 export const bnUint32Max = BigNumber.from("0xffffffff");
 export const bnUint256Max = BigNumber.from("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 
+/**
+ * BigInt min/max helpers.
+ */
+export const biMin = (a: bigint, b: bigint) => (a > b ? b : a);
+export const biMax = (a: bigint, b: bigint) => (a > b ? a : b);
+
 /**
  * Converts a stringified number into a BigNumber with 18 decimal places.
  * @param num The number to parse.

package/src/utils/DepositUtils.ts

@@ -265,7 +265,7 @@ export function resolveDepositMessage(deposit: Deposit): string {
  * Converts a RelayData object with `Address` types as address fields to a `RelayData`-like object with
  * strings as address fields.
  * @param relayData RelayData type.
- * @returns a RelayData-like type which has strings as fields.
+ * @returns a RelayData-like type which has hex 32 byte strings as fields.
  */
 export function convertRelayDataParamsToBytes32(relayData: RelayData): ConvertedRelayData {
   return {
@@ -282,7 +282,7 @@ export function convertRelayDataParamsToBytes32(relayData: RelayData): Converted
  * Converts a Fill object with `Address` types as address fields to a `RelayData`-like object with
  * strings as address fields.
  * @param relayData RelayData type.
- * @returns a RelayData-like type which has strings as fields.
+ * @returns a RelayData-like type which has hex 32 byte strings as fields.
  */
 export function convertFillParamsToBytes32(fill: Fill): ConvertedFill {
   return {
@@ -299,3 +299,42 @@ export function convertFillParamsToBytes32(fill: Fill): ConvertedFill {
     },
   };
 }
+
+/**
+ * Converts a RelayData object with `Address` types as address fields to a `RelayData`-like object with
+ * strings as address fields.
+ * @param relayData RelayData type.
+ * @returns a RelayData-like type which has native address representation strings as fields.
+ */
+export function convertRelayDataParamsToNative(relayData: RelayData): ConvertedRelayData {
+  return {
+    ...relayData,
+    depositor: relayData.depositor.toNative(),
+    recipient: relayData.recipient.toNative(),
+    inputToken: relayData.inputToken.toNative(),
+    outputToken: relayData.outputToken.toNative(),
+    exclusiveRelayer: relayData.exclusiveRelayer.toNative(),
+  };
+}
+
+/**
+ * Converts a Fill object with `Address` types as address fields to a `RelayData`-like object with
+ * strings as address fields.
+ * @param relayData RelayData type.
+ * @returns a RelayData-like type which has native address representation strings as fields.
+ */
+export function convertFillParamsToNative(fill: Fill): ConvertedFill {
+  return {
+    ...fill,
+    depositor: fill.depositor.toNative(),
+    recipient: fill.recipient.toNative(),
+    inputToken: fill.inputToken.toNative(),
+    outputToken: fill.outputToken.toNative(),
+    exclusiveRelayer: fill.exclusiveRelayer.toNative(),
+    relayer: fill.relayer.toNative(),
+    relayExecutionInfo: {
+      ...fill.relayExecutionInfo,
+      updatedRecipient: fill.relayExecutionInfo.updatedRecipient.toNative(),
+    },
+  };
+}

package/src/utils/TokenUtils.ts

@@ -58,12 +58,12 @@ export function resolveSymbolOnChain(chainId: number, symbol: string): TokenInfo
  */
 export const resolveContractFromSymbol = (
   symbol: string,
-  chainId: string,
+  chainId: number,
   tokenMapping = TOKEN_SYMBOLS_MAP
 ): string | undefined => {
   return Object.values(tokenMapping).find((details) => {
     return details.symbol.toLowerCase() === symbol.toLowerCase();
-  })?.addresses[Number(chainId)];
+  })?.addresses[chainId];
 };
 
 export function getCoingeckoTokenIdByAddress(address: string, chainId: number): string {