@across-protocol/sdk 4.3.152 → 4.3.154

package/src/coingecko/Coingecko.ts

@@ -1,6 +1,7 @@
 import assert from "assert";
 import { fetchWithTimeout, getCoingeckoTokenIdByAddress, retry } from "../utils";
 import { Logger } from "../relayFeeCalculator";
+import { CoingeckoPriceNotFoundError } from "./CoingeckoErrors";
 
 export function msToS(ms: number) {
   return Math.floor(ms / 1000);
@@ -206,7 +207,9 @@ export class Coingecko {
     const _from = msToS(from);
     const _to = msToS(to);
     const result = await this.call<HistoricPriceChartData>(
-      `coins/ethereum/contract/${contract.toLowerCase()}/market_chart/range/?vs_currency=${currency}&from=${_from}&to=${_to}`
+      `coins/ethereum/contract/${encodeURIComponent(
+        contract.toLowerCase()
+      )}/market_chart/range/?vs_currency=${encodeURIComponent(currency)}&from=${_from}&to=${_to}`
     );
     // fyi timestamps are returned in ms in contrast to the current price endpoint
     if (result.prices) return result.prices;
@@ -230,7 +233,7 @@ export class Coingecko {
     const coingeckoTokenIdentifier = await this.getCoingeckoTokenId(contractAddress, chainId);
     assert(date, "Requires date string");
     // Build the path for the Coingecko API request
-    const url = `coins/${coingeckoTokenIdentifier}/history`;
+    const url = `coins/${encodeURIComponent(coingeckoTokenIdentifier)}/history`;
     // Build the query parameters for the Coingecko API request
     const queryParams = {
       date,
@@ -244,7 +247,9 @@ export class Coingecko {
   }
 
   getContractDetails(contract_address: string, platform_id = "ethereum") {
-    return this.call(`coins/${platform_id}/contract/${contract_address.toLowerCase()}`);
+    return this.call(
+      `coins/${encodeURIComponent(platform_id)}/contract/${encodeURIComponent(contract_address.toLowerCase())}`
+    );
   }
 
   async getCurrentPriceByContract(contractAddress: string, currency = "usd", chainId = 1): Promise<[string, number]> {
@@ -256,7 +261,9 @@ export class Coingecko {
       tokenPrice = priceCache[contractAddress];
     }
 
-    assert(tokenPrice !== undefined);
+    if (tokenPrice === undefined) {
+      throw new CoingeckoPriceNotFoundError({ identifier: contractAddress, currency, lookupType: "address" });
+    }
     return [tokenPrice.timestamp.toString(), tokenPrice.price];
   }
 
@@ -268,22 +275,25 @@ export class Coingecko {
       const coingeckoId = await this.getCoingeckoTokenId(contractAddress, chainId);
       // Build the path for the Coingecko API request
       const result = await this.call<Record<string, CGTokenPrice>>(
-        `simple/price?ids=${coingeckoId}&vs_currencies=${currency}&include_last_updated_at=true`
+        `simple/price?ids=${encodeURIComponent(coingeckoId)}&vs_currencies=${encodeURIComponent(
+          currency
+        )}&include_last_updated_at=true`
       );
       const cgPrice = result?.[coingeckoId];
       if (cgPrice === undefined || !cgPrice?.[currency]) {
-        const errMsg = `No price found for ${coingeckoId}`;
         this.logger.debug({
           at: "Coingecko#getCurrentPriceById",
-          message: errMsg,
+          message: `No Coingecko price found for id '${coingeckoId}' in ${currency}`,
         });
-        throw new Error(errMsg);
+        throw new CoingeckoPriceNotFoundError({ identifier: coingeckoId, currency, lookupType: "id" });
       } else {
         this.updatePriceCache(cgPrice, contractAddress, currency, platform_id);
       }
     }
     tokenPrice = priceCache[contractAddress];
-    assert(tokenPrice !== undefined);
+    if (tokenPrice === undefined) {
+      throw new CoingeckoPriceNotFoundError({ identifier: contractAddress, currency, lookupType: "address" });
+    }
     return [tokenPrice.timestamp.toString(), tokenPrice.price];
   }
 
@@ -291,22 +301,25 @@ export class Coingecko {
     let tokenPrice = this.getCachedSymbolPrice(symbol, currency);
     if (tokenPrice === undefined) {
       const result = await this.call<Record<string, CGTokenPrice>>(
-        `simple/price?symbols=${symbol}&vs_currencies=${currency}&include_last_updated_at=true`
+        `simple/price?symbols=${encodeURIComponent(symbol)}&vs_currencies=${encodeURIComponent(
+          currency
+        )}&include_last_updated_at=true`
       );
       const cgPrice = result?.[symbol.toLowerCase()] || result?.[symbol.toUpperCase()];
       if (cgPrice === undefined || !cgPrice?.[currency]) {
-        const errMsg = `Failed to retrieve ${symbol}/${currency} price via Coingecko API`;
         this.logger.debug({
           at: "Coingecko#getCurrentPriceBySymbol",
-          message: errMsg,
+          message: `No Coingecko price found for symbol '${symbol}' in ${currency}`,
         });
-        throw new Error(errMsg);
+        throw new CoingeckoPriceNotFoundError({ identifier: symbol, currency, lookupType: "symbol" });
       } else {
         this.updatePriceCacheBySymbol(cgPrice, symbol, currency);
       }
     }
     tokenPrice = this.getCachedSymbolPrice(symbol, currency);
-    assert(tokenPrice !== undefined);
+    if (tokenPrice === undefined) {
+      throw new CoingeckoPriceNotFoundError({ identifier: symbol, currency, lookupType: "symbol" });
+    }
     return [tokenPrice.timestamp.toString(), tokenPrice.price];
   }
 
@@ -344,9 +357,9 @@ export class Coingecko {
     try {
       // Coingecko expects a comma-delimited (%2c) list.
       result = await this.call(
-        `simple/token_price/${platform_id}?contract_addresses=${contract_addresses.join(
-          "%2C"
-        )}&vs_currencies=${currency}&include_last_updated_at=true`
+        `simple/token_price/${encodeURIComponent(platform_id)}?contract_addresses=${contract_addresses
+          .map((addr) => encodeURIComponent(addr))
+          .join("%2C")}&vs_currencies=${encodeURIComponent(currency)}&include_last_updated_at=true`
       );
     } catch (err) {
       const errMsg = `Failed to retrieve ${platform_id}/${currency} prices (${err})`;

package/src/coingecko/CoingeckoErrors.ts

@@ -0,0 +1,24 @@
+/**
+ * Thrown when a price lookup against the Coingecko API does not return a
+ * usable price for the requested identifier. Callers can use `instanceof` to
+ * map this to a 404 / not-found response without needing to string-match
+ * the underlying message.
+ */
+export type CoingeckoLookupType = "symbol" | "address" | "id";
+
+export class CoingeckoPriceNotFoundError extends Error {
+  readonly identifier: string;
+  readonly currency: string;
+  readonly lookupType: CoingeckoLookupType;
+
+  constructor(args: { identifier: string; currency: string; lookupType: CoingeckoLookupType; cause?: unknown }) {
+    super(
+      `No Coingecko price found for ${args.lookupType} '${args.identifier}' in ${args.currency}`,
+      args.cause !== undefined ? { cause: args.cause } : undefined
+    );
+    this.name = "CoingeckoPriceNotFoundError";
+    this.identifier = args.identifier;
+    this.currency = args.currency;
+    this.lookupType = args.lookupType;
+  }
+}

package/src/coingecko/index.ts

@@ -1 +1,2 @@
 export * from "./Coingecko";
+export * from "./CoingeckoErrors";

package/src/gasPriceOracle/adapters/solana.ts

@@ -1,14 +1,18 @@
 import { SVMProvider } from "../../arch/svm";
-import { toBN, dedupArray } from "../../utils";
+import { BN, toBN, dedupArray } from "../../utils";
 import { SvmGasPriceEstimate } from "../types";
 import { GasPriceEstimateOptions } from "../oracle";
+import { SvmGasPriceUnavailableError } from "../errors";
 import {
   TransactionMessage,
   TransactionMessageBytesBase64,
   TransactionMessageWithFeePayer,
   compileTransaction,
+  setTransactionMessageLifetimeUsingBlockhash,
 } from "@solana/kit";
 
+const MAX_BASE_FEE_ATTEMPTS = 2;
+
 /**
  * @notice Returns result of getFeeForMessage and getRecentPrioritizationFees RPC calls.
  * @returns GasPriceEstimate
@@ -18,13 +22,8 @@ export async function messageFee(provider: SVMProvider, opts: GasPriceEstimateOp
 
   // Cast the opaque unsignedTx type to a solana-kit TransactionMessage with fee payer.
   const unsignedTx = _unsignedTx as TransactionMessage & TransactionMessageWithFeePayer;
-  const compiledTransaction = compileTransaction(unsignedTx);
 
-  // Get this base fee. This should result in LAMPORTS_PER_SIGNATURE * nSignatures.
-  const encodedTransactionMessage = Buffer.from(compiledTransaction.messageBytes).toString(
-    "base64"
-  ) as TransactionMessageBytesBase64;
-  const baseFeeResponse = await provider.getFeeForMessage(encodedTransactionMessage).send();
+  const baseFee = await getBaseFee(provider, unsignedTx);
 
   // Get the priority fee by calling `getRecentPrioritzationFees` on all the addresses in the transaction's instruction array.
   const instructionAddresses = dedupArray(unsignedTx.instructions.map((instruction) => instruction.programAddress));
@@ -40,8 +39,29 @@ export async function messageFee(provider: SVMProvider, opts: GasPriceEstimateOp
   const microLamportsPerComputeUnit = toBN(
     totalPrioritizationFees / BigInt(Math.max(nonzeroPrioritizationFees.length, 1))
   );
-  return {
-    baseFee: toBN(baseFeeResponse!.value!),
-    microLamportsPerComputeUnit,
-  };
+
+  return { baseFee, microLamportsPerComputeUnit };
+}
+
+// `getFeeForMessage` returns `{ value: null }` when the cluster has not yet recognised
+// the blockhash referenced by the message. With a load-balanced RPC pool, this happens
+// when the request lands on a node that hasn't seen the blockhash from an earlier
+// `getLatestBlockhash` call. We side-step the race by always refreshing to a `confirmed`
+// blockhash before each attempt — by definition propagated to all healthy nodes — and
+// retrying once if a fee call still comes back null. Fee estimation is never sent
+// on-chain, so blockhash freshness doesn't matter.
+async function getBaseFee(provider: SVMProvider, tx: TransactionMessage & TransactionMessageWithFeePayer): Promise<BN> {
+  for (let attempt = 0; attempt < MAX_BASE_FEE_ATTEMPTS; attempt++) {
+    const { value: confirmedBlockhash } = await provider.getLatestBlockhash({ commitment: "confirmed" }).send();
+    const refreshedTx = setTransactionMessageLifetimeUsingBlockhash(confirmedBlockhash, tx);
+    const compiled = compileTransaction(refreshedTx);
+    const encoded = Buffer.from(compiled.messageBytes).toString("base64") as TransactionMessageBytesBase64;
+    const { value } = await provider.getFeeForMessage(encoded).send();
+    if (value !== null && value !== undefined) {
+      return toBN(value);
+    }
+  }
+  throw new SvmGasPriceUnavailableError(
+    "Solana getFeeForMessage returned null even after retrying with a confirmed blockhash"
+  );
 }

package/src/gasPriceOracle/errors.ts

@@ -0,0 +1,14 @@
+/**
+ * Thrown when the SVM gas-price oracle cannot determine a base fee for the
+ * supplied message — most commonly because Solana's `getFeeForMessage` RPC
+ * returned `{ value: null }` even after retrying with a confirmed blockhash.
+ *
+ * Callers can use `instanceof` to map this to a transient upstream-RPC error
+ * (e.g. HTTP 502 / 503) rather than treating it as an unhandled exception.
+ */
+export class SvmGasPriceUnavailableError extends Error {
+  constructor(message: string, opts?: { cause?: unknown }) {
+    super(message, opts?.cause !== undefined ? { cause: opts.cause } : undefined);
+    this.name = "SvmGasPriceUnavailableError";
+  }
+}

package/src/gasPriceOracle/index.ts

@@ -1,2 +1,3 @@
 export { getGasPriceEstimate, GasPriceEstimateOptions } from "./oracle";
 export { GasPriceEstimate, EvmGasPriceEstimate, SvmGasPriceEstimate } from "./types";
+export { SvmGasPriceUnavailableError } from "./errors";

package/src/utils/DepositUtils.ts

@@ -8,6 +8,7 @@ import {
   Fill,
   RelayData,
   SlowFillRequest,
+  SpeedUpCommon,
   ConvertedRelayData,
   ConvertedFill,
 } from "../interfaces";
@@ -244,10 +245,16 @@ export function isFillOrSlowFillRequestMessageEmpty(message: string): boolean {
 /**
  * Determines if a deposit was updated via a speed-up transaction.
  * @param deposit Deposit to evaluate.
- * @returns True if the deposit was updated, otherwise false.
+ * @returns True if the deposit was updated, otherwise false. Narrows the deposit type so callers
+ *          can safely access updatedRecipient/updatedOutputAmount/updatedMessage/speedUpSignature.
  */
-export function isDepositSpedUp(deposit: Deposit): boolean {
-  return isDefined(deposit.speedUpSignature) && isDefined(deposit.updatedOutputAmount);
+export function isDepositSpedUp(deposit: Deposit): deposit is Deposit & SpeedUpCommon & { speedUpSignature: string } {
+  return (
+    isDefined(deposit.speedUpSignature) &&
+    isDefined(deposit.updatedOutputAmount) &&
+    isDefined(deposit.updatedRecipient) &&
+    isDefined(deposit.updatedMessage)
+  );
 }
 
 /**