thirdweb 5.99.3 → 5.100.0

package/src/pay/buyWithCrypto/getTransfer.ts

@@ -1,17 +1,13 @@
-import type { Hash } from "viem";
+import { Value } from "ox";
+import * as ox__AbiFunction from "ox/AbiFunction";
+import { Transfer } from "../../bridge/index.js";
 import { getCachedChain } from "../../chains/utils.js";
 import type { ThirdwebClient } from "../../client/client.js";
+import { NATIVE_TOKEN_ADDRESS } from "../../constants/addresses.js";
+import { getContract } from "../../contract/contract.js";
+import { decimals } from "../../extensions/erc20/read/decimals.js";
 import type { PrepareTransactionOptions } from "../../transaction/prepare-transaction.js";
-import type { Address } from "../../utils/address.js";
-import { getClientFetch } from "../../utils/fetch.js";
-import { stringify } from "../../utils/json.js";
-import { getPayBuyWithCryptoTransferEndpoint } from "../utils/definitions.js";
-import type {
-  QuoteApprovalInfo,
-  QuotePaymentToken,
-  QuoteTokenInfo,
-  QuoteTransactionRequest,
-} from "./commonTypes.js";
+import type { QuoteApprovalInfo, QuotePaymentToken } from "./commonTypes.js";
 
 /**
  * The parameters for [`getBuyWithCryptoTransfer`](https://portal.thirdweb.com/references/typescript/v5/getBuyWithCryptoTransfer) function
@@ -66,21 +62,6 @@ export type GetBuyWithCryptoTransferParams = {
   feePayer?: "sender" | "receiver";
 };
 
-/**
- * @buyCrypto
- */
-type BuyWithCryptoTransferResponse = {
-  quoteId: string;
-  transactionRequest: QuoteTransactionRequest;
-  approval?: QuoteApprovalInfo;
-  fromAddress: string;
-  toAddress: string;
-  token: QuoteTokenInfo;
-  paymentToken: QuotePaymentToken;
-  processingFee: QuotePaymentToken;
-  estimatedGasCostUSDCents: number;
-};
-
 /**
  * @buyCrypto
  */
@@ -126,50 +107,137 @@ export async function getBuyWithCryptoTransfer(
   params: GetBuyWithCryptoTransferParams,
 ): Promise<BuyWithCryptoTransfer> {
   try {
-    const clientFetch = getClientFetch(params.client);
-
-    const response = await clientFetch(getPayBuyWithCryptoTransferEndpoint(), {
-      method: "POST",
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json",
-      },
-      body: stringify({
-        fromAddress: params.fromAddress,
-        toAddress: params.toAddress,
-        chainId: params.chainId,
-        tokenAddress: params.tokenAddress,
-        amount: params.amount,
-        purchaseData: params.purchaseData,
-        feePayer: params.feePayer,
-      }),
+    const tokenContract = getContract({
+      address: params.tokenAddress,
+      chain: getCachedChain(params.chainId),
+      client: params.client,
+    });
+    const tokenDecimals =
+      tokenContract.address.toLowerCase() === NATIVE_TOKEN_ADDRESS
+        ? 18
+        : await decimals({
+            contract: tokenContract,
+          });
+    const amount = Value.from(params.amount, tokenDecimals);
+    const quote = await Transfer.prepare({
+      chainId: params.chainId,
+      tokenAddress: params.tokenAddress,
+      amount,
+      sender: params.fromAddress,
+      receiver: params.toAddress,
+      client: params.client,
+      feePayer: params.feePayer,
     });
 
-    if (!response.ok) {
-      const errorObj = await response.json();
-      if (errorObj && "error" in errorObj) {
-        throw errorObj;
-      }
-      throw new Error(`HTTP error! status: ${response.status}`);
+    const firstStep = quote.steps[0];
+    if (!firstStep) {
+      throw new Error(
+        "This quote is incompatible with getBuyWithCryptoTransfer. Please use Bridge.Transfer.prepare instead.",
+      );
     }
 
-    const data: BuyWithCryptoTransferResponse = (await response.json()).result;
+    const approvalTxs = firstStep.transactions.filter(
+      (tx) => tx.action === "approval",
+    );
+    if (approvalTxs.length > 1) {
+      throw new Error(
+        "This quote is incompatible with getBuyWithCryptoTransfer. Please use Bridge.Transfer.prepare instead.",
+      );
+    }
+    const approvalTx = approvalTxs[0];
+
+    let approvalData: QuoteApprovalInfo | undefined;
+    if (approvalTx) {
+      const abiFunction = ox__AbiFunction.from([
+        "function approve(address spender, uint256 amount)",
+      ]);
+      const [spender, amount] = ox__AbiFunction.decodeData(
+        abiFunction,
+        approvalTx.data,
+      );
+      approvalData = {
+        chainId: firstStep.originToken.chainId,
+        tokenAddress: firstStep.originToken.address,
+        spenderAddress: spender,
+        amountWei: amount.toString(),
+      };
+    }
+
+    const txs = firstStep.transactions.filter((tx) => tx.action !== "approval");
+    if (txs.length > 1) {
+      throw new Error(
+        "This quote is incompatible with getBuyWithCryptoTransfer. Please use Bridge.Transfer.prepare instead.",
+      );
+    }
+    const tx = txs[0];
+    if (!tx) {
+      throw new Error(
+        "This quote is incompatible with getBuyWithCryptoTransfer. Please use Bridge.Transfer.prepare instead.",
+      );
+    }
 
     const transfer: BuyWithCryptoTransfer = {
       transactionRequest: {
-        chain: getCachedChain(data.transactionRequest.chainId),
-        client: params.client,
-        data: data.transactionRequest.data as Hash,
-        to: data.transactionRequest.to as Address,
-        value: BigInt(data.transactionRequest.value),
+        ...tx,
         extraGas: 50000n, // extra gas buffer
       },
-      approvalData: data.approval,
-      fromAddress: data.fromAddress,
-      toAddress: data.toAddress,
-      paymentToken: data.paymentToken,
-      processingFee: data.processingFee,
-      estimatedGasCostUSDCents: data.estimatedGasCostUSDCents,
+      approvalData,
+      fromAddress: params.fromAddress,
+      toAddress: params.toAddress,
+      paymentToken: {
+        token: {
+          tokenAddress: firstStep.originToken.address,
+          chainId: firstStep.originToken.chainId,
+          decimals: firstStep.originToken.decimals,
+          symbol: firstStep.originToken.symbol,
+          name: firstStep.originToken.name,
+          priceUSDCents: firstStep.originToken.priceUsd * 100,
+        },
+        amountWei: quote.originAmount.toString(),
+        amount: Value.format(
+          quote.originAmount,
+          firstStep.originToken.decimals,
+        ).toString(),
+        amountUSDCents:
+          Number(
+            Value.format(quote.originAmount, firstStep.originToken.decimals),
+          ) *
+          firstStep.originToken.priceUsd *
+          100,
+      },
+      processingFee: {
+        token: {
+          tokenAddress: firstStep.originToken.address,
+          chainId: firstStep.originToken.chainId,
+          decimals: firstStep.originToken.decimals,
+          symbol: firstStep.originToken.symbol,
+          name: firstStep.originToken.name,
+          priceUSDCents: firstStep.originToken.priceUsd * 100,
+        },
+        amountWei:
+          params.feePayer === "sender"
+            ? (quote.originAmount - quote.destinationAmount).toString()
+            : "0",
+        amount:
+          params.feePayer === "sender"
+            ? Value.format(
+                quote.originAmount - quote.destinationAmount,
+                firstStep.originToken.decimals,
+              ).toString()
+            : "0",
+        amountUSDCents:
+          params.feePayer === "sender"
+            ? Number(
+                Value.format(
+                  quote.originAmount - quote.destinationAmount,
+                  firstStep.originToken.decimals,
+                ),
+              ) *
+              firstStep.originToken.priceUsd *
+              100
+            : 0,
+      },
+      estimatedGasCostUSDCents: 0,
       client: params.client,
     };
 

package/src/pay/buyWithFiat/getQuote.ts

@@ -1,9 +1,12 @@
+import { prepare as prepareOnramp } from "../../bridge/Onramp.js";
+import { getCachedChain } from "../../chains/utils.js";
 import type { ThirdwebClient } from "../../client/client.js";
+import { NATIVE_TOKEN_ADDRESS } from "../../constants/addresses.js";
+import { getContract } from "../../contract/contract.js";
+import { decimals } from "../../extensions/erc20/read/decimals.js";
 import type { CurrencyMeta } from "../../react/web/ui/ConnectWallet/screens/Buy/fiat/currencies.js";
-import { getClientFetch } from "../../utils/fetch.js";
-import { stringify } from "../../utils/json.js";
+import { toTokens, toUnits } from "../../utils/units.js";
 import type { FiatProvider, PayTokenInfo } from "../utils/commonTypes.js";
-import { getPayBuyWithFiatQuoteEndpoint } from "../utils/definitions.js";
 /**
  * Parameters for [`getBuyWithFiatQuote`](https://portal.thirdweb.com/references/typescript/v5/getBuyWithFiatQuote) function
  * @deprecated
@@ -274,41 +277,189 @@ export async function getBuyWithFiatQuote(
   params: GetBuyWithFiatQuoteParams,
 ): Promise<BuyWithFiatQuote> {
   try {
-    const clientFetch = getClientFetch(params.client);
+    // map preferred provider (FiatProvider) → onramp string expected by Onramp.prepare
+    const mapProviderToOnramp = (
+      provider?: FiatProvider,
+    ): "stripe" | "coinbase" | "transak" => {
+      switch (provider) {
+        case "STRIPE":
+          return "stripe";
+        case "TRANSAK":
+          return "transak";
+        default: // default to coinbase when undefined or any other value
+          return "coinbase";
+      }
+    };
 
-    const response = await clientFetch(getPayBuyWithFiatQuoteEndpoint(), {
-      method: "POST",
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json",
-      },
-      body: stringify({
-        toAddress: params.toAddress,
-        fromCurrencySymbol: params.fromCurrencySymbol,
-        toChainId: params.toChainId.toString(),
-        toTokenAddress: params.toTokenAddress,
-        fromAmount: params.fromAmount,
-        toAmount: params.toAmount,
-        maxSlippageBPS: params.maxSlippageBPS,
-        isTestMode: params.isTestMode,
-        purchaseData: params.purchaseData,
-        fromAddress: params.fromAddress,
-        toGasAmountWei: params.toGasAmountWei,
-        preferredProvider: params.preferredProvider,
-        multiHopSupported: true,
-      }),
+    // Choose provider or default to STRIPE
+    const onrampProvider = mapProviderToOnramp(params.preferredProvider);
+
+    const d =
+      params.toTokenAddress !== NATIVE_TOKEN_ADDRESS
+        ? await decimals({
+            contract: getContract({
+              client: params.client,
+              address: params.toTokenAddress,
+              chain: getCachedChain(params.toChainId),
+            }),
+          })
+        : 18;
+
+    // Prepare amount in wei if provided
+    const amountWei = params.toAmount ? toUnits(params.toAmount, d) : undefined;
+
+    // Call new Onramp.prepare to get the quote & link
+    const prepared = await prepareOnramp({
+      client: params.client,
+      onramp: onrampProvider,
+      chainId: params.toChainId,
+      tokenAddress: params.toTokenAddress,
+      receiver: params.toAddress,
+      sender: params.fromAddress,
+      amount: amountWei,
+      purchaseData: params.purchaseData,
+      currency: params.fromCurrencySymbol,
+      maxSteps: 2,
+      onrampTokenAddress: NATIVE_TOKEN_ADDRESS, // force onramp to native token to avoid missing gas issues
     });
 
-    // Assuming the response directly matches the SwapResponse interface
-    if (!response.ok) {
-      const errorObj = await response.json();
-      if (errorObj && "error" in errorObj) {
-        throw errorObj;
-      }
-      throw new Error(`HTTP error! status: ${response.status}`);
+    // Determine tokens based on steps rules
+    const hasSteps = prepared.steps.length > 0;
+    const firstStep = hasSteps
+      ? (prepared.steps[0] as (typeof prepared.steps)[number])
+      : undefined;
+
+    // Estimated duration in seconds – sum of all step durations
+    const estimatedDurationSeconds = Math.max(
+      120,
+      Math.ceil(
+        prepared.steps.reduce((acc, s) => acc + s.estimatedExecutionTimeMs, 0) /
+          1000,
+      ),
+    );
+
+    const estimatedToAmountMinWeiBigInt = prepared.destinationAmount;
+
+    const maxSlippageBPS = params.maxSlippageBPS ?? 0;
+    const slippageWei =
+      (estimatedToAmountMinWeiBigInt * BigInt(maxSlippageBPS)) / 10000n;
+    const toAmountMinWeiBigInt = estimatedToAmountMinWeiBigInt - slippageWei;
+
+    const estimatedToAmountMin = toTokens(estimatedToAmountMinWeiBigInt, d);
+    const toAmountMin = toTokens(toAmountMinWeiBigInt, d);
+
+    // Helper to convert a Token → PayTokenInfo
+    const tokenToPayTokenInfo = (token: {
+      chainId: number;
+      address: string;
+      decimals: number;
+      symbol: string;
+      name: string;
+      priceUsd: number;
+    }): PayTokenInfo => ({
+      chainId: token.chainId,
+      tokenAddress: token.address,
+      decimals: token.decimals,
+      priceUSDCents: Math.round(token.priceUsd * 100),
+      name: token.name,
+      symbol: token.symbol,
+    });
+
+    // Determine the raw token objects using new simplified rules
+    // 1. toToken is always the destination token
+    const toTokenRaw = prepared.destinationToken;
+
+    // 2. onRampToken: if exactly one step -> originToken of that step, else toTokenRaw
+    const onRampTokenRaw =
+      prepared.steps.length > 0 && firstStep
+        ? firstStep.originToken
+        : toTokenRaw;
+
+    // 3. routingToken: if exactly two steps -> originToken of second step, else undefined
+    const routingTokenRaw =
+      prepared.steps.length > 1
+        ? (prepared.steps[1] as (typeof prepared.steps)[number]).originToken
+        : undefined;
+
+    // Amounts for onRampToken/raw
+    const onRampTokenAmountWei: bigint =
+      prepared.steps.length > 0 && firstStep
+        ? firstStep.originAmount
+        : prepared.destinationAmount;
+
+    const onRampTokenAmount = toTokens(
+      onRampTokenAmountWei,
+      onRampTokenRaw.decimals,
+    );
+
+    // Build info objects
+    const onRampTokenObject = {
+      amount: onRampTokenAmount,
+      amountWei: onRampTokenAmountWei.toString(),
+      amountUSDCents: Math.round(
+        Number(onRampTokenAmount) * onRampTokenRaw.priceUsd * 100,
+      ),
+      token: tokenToPayTokenInfo(onRampTokenRaw),
+    };
+
+    let routingTokenObject:
+      | {
+          amount: string;
+          amountWei: string;
+          amountUSDCents: number;
+          token: PayTokenInfo;
+        }
+      | undefined;
+
+    if (routingTokenRaw) {
+      const routingAmountWei = (
+        prepared.steps[1] as (typeof prepared.steps)[number]
+      ).originAmount;
+      const routingAmount = toTokens(
+        routingAmountWei,
+        routingTokenRaw.decimals,
+      );
+      routingTokenObject = {
+        amount: routingAmount,
+        amountWei: routingAmountWei.toString(),
+        amountUSDCents: Math.round(
+          Number(routingAmount) * routingTokenRaw.priceUsd * 100,
+        ),
+        token: tokenToPayTokenInfo(routingTokenRaw),
+      };
     }
 
-    return (await response.json()).result;
+    const buyWithFiatQuote: BuyWithFiatQuote = {
+      estimatedDurationSeconds,
+      estimatedToAmountMin: estimatedToAmountMin,
+      estimatedToAmountMinWei: estimatedToAmountMinWeiBigInt.toString(),
+      toAmountMinWei: toAmountMinWeiBigInt.toString(),
+      toAmountMin: toAmountMin,
+      fromCurrency: {
+        amount: prepared.currencyAmount.toString(),
+        amountUnits: Number(prepared.currencyAmount).toFixed(2),
+        decimals: 2,
+        currencySymbol: prepared.currency,
+      },
+      fromCurrencyWithFees: {
+        amount: prepared.currencyAmount.toString(),
+        amountUnits: Number(prepared.currencyAmount).toFixed(2),
+        decimals: 2,
+        currencySymbol: prepared.currency,
+      },
+      toToken: tokenToPayTokenInfo(toTokenRaw),
+      toAddress: params.toAddress,
+      fromAddress: params.fromAddress,
+      maxSlippageBPS: maxSlippageBPS,
+      intentId: prepared.id,
+      processingFees: [],
+      onRampToken: onRampTokenObject,
+      routingToken: routingTokenObject,
+      onRampLink: prepared.link,
+      provider: (params.preferredProvider ?? "COINBASE") as FiatProvider,
+    };
+
+    return buyWithFiatQuote;
   } catch (error) {
     console.error("Error getting buy with fiat quote", error);
     throw error;

package/src/pay/buyWithFiat/getStatus.ts

@@ -1,10 +1,9 @@
+import { status as onrampStatus } from "../../bridge/OnrampStatus.js";
 import type { ThirdwebClient } from "../../client/client.js";
-import { getClientFetch } from "../../utils/fetch.js";
 import type {
   PayOnChainTransactionDetails,
   PayTokenInfo,
 } from "../utils/commonTypes.js";
-import { getPayBuyWithFiatStatusEndpoint } from "../utils/definitions.js";
 
 /**
  * Parameters for the [`getBuyWithFiatStatus`](https://portal.thirdweb.com/references/typescript/v5/getBuyWithFiatStatus) function
@@ -25,11 +24,6 @@ export type GetBuyWithFiatStatusParams = {
   intentId: string;
 };
 
-export type ValidBuyWithFiatStatus = Exclude<
-  BuyWithFiatStatus,
-  { status: "NOT_FOUND" }
->;
-
 /**
  * The returned object from [`getBuyWithFiatStatus`](https://portal.thirdweb.com/references/typescript/v5/getBuyWithFiatStatus) function
  *
@@ -50,28 +44,13 @@ export type BuyWithFiatStatus =
        * - `NONE` - No status
        * - `PENDING_PAYMENT` - Payment is not done yet in the on-ramp provider
        * - `PAYMENT_FAILED` - Payment failed in the on-ramp provider
-       * - `PENDING_ON_RAMP_TRANSFER` - Payment is done but the on-ramp provider is yet to transfer the tokens to the user's wallet
-       * - `ON_RAMP_TRANSFER_IN_PROGRESS` - On-ramp provider is transferring the tokens to the user's wallet
        * - `ON_RAMP_TRANSFER_COMPLETED` - On-ramp provider has transferred the tokens to the user's wallet
-       * - `ON_RAMP_TRANSFER_FAILED` - On-ramp provider failed to transfer the tokens to the user's wallet
-       * - `CRYPTO_SWAP_REQUIRED` - On-ramp provider has sent the tokens to the user's wallet but a swap is required to convert it to the desired token
-       * - `CRYPTO_SWAP_IN_PROGRESS` - Swap is in progress
-       * - `CRYPTO_SWAP_COMPLETED` - Swap is completed and the user has received the desired token
-       * - `CRYPTO_SWAP_FALLBACK` - Swap failed and the user has received a fallback token which is not the desired token
        */
       status:
         | "NONE"
         | "PENDING_PAYMENT"
         | "PAYMENT_FAILED"
-        | "PENDING_ON_RAMP_TRANSFER"
-        | "ON_RAMP_TRANSFER_IN_PROGRESS"
-        | "ON_RAMP_TRANSFER_COMPLETED"
-        | "ON_RAMP_TRANSFER_FAILED"
-        | "CRYPTO_SWAP_REQUIRED"
-        | "CRYPTO_SWAP_COMPLETED"
-        | "CRYPTO_SWAP_FALLBACK"
-        | "CRYPTO_SWAP_IN_PROGRESS"
-        | "CRYPTO_SWAP_FAILED";
+        | "ON_RAMP_TRANSFER_COMPLETED";
       /**
        * The wallet address to which the desired tokens are sent to
        */
@@ -171,7 +150,6 @@ export type BuyWithFiatStatus =
  * })
  *
  * // when the fiatStatus.status is "ON_RAMP_TRANSFER_COMPLETED" - the process is complete
- * // when the fiatStatus.status is "CRYPTO_SWAP_REQUIRED" - start the swap process
  * ```
  * @deprecated
  * @buyCrypto
@@ -179,26 +157,107 @@ export type BuyWithFiatStatus =
 export async function getBuyWithFiatStatus(
   params: GetBuyWithFiatStatusParams,
 ): Promise<BuyWithFiatStatus> {
-  try {
-    const queryParams = new URLSearchParams({
-      intentId: params.intentId,
-    });
+  const result = await onrampStatus({
+    id: params.intentId,
+    client: params.client,
+  });
 
-    const queryString = queryParams.toString();
-    const url = `${getPayBuyWithFiatStatusEndpoint()}?${queryString}`;
+  return toBuyWithFiatStatus({ intentId: params.intentId, result });
+}
 
-    const response = await getClientFetch(params.client)(url);
+////////////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////////////
 
-    if (!response.ok) {
-      const error = await response.text().catch(() => null);
-      throw new Error(
-        `HTTP error! status: ${response.status} - ${response.statusText}: ${error || "unknown error"}`,
-      );
-    }
+function toBuyWithFiatStatus(args: {
+  intentId: string;
+  result: Awaited<ReturnType<typeof onrampStatus>>;
+}): BuyWithFiatStatus {
+  const { intentId, result } = args;
+
+  // Map status constants from the Bridge.Onramp.status response to BuyWithFiatStatus equivalents.
+  const STATUS_MAP: Record<
+    typeof result.status,
+    "NONE" | "PENDING_PAYMENT" | "PAYMENT_FAILED" | "ON_RAMP_TRANSFER_COMPLETED"
+  > = {
+    CREATED: "PENDING_PAYMENT",
+    PENDING: "PENDING_PAYMENT",
+    FAILED: "PAYMENT_FAILED",
+    COMPLETED: "ON_RAMP_TRANSFER_COMPLETED",
+  } as const;
+
+  const mappedStatus = STATUS_MAP[result.status];
+
+  return buildPlaceholderStatus({
+    intentId,
+    status: mappedStatus,
+    purchaseData: result.purchaseData,
+  });
+}
+
+function buildPlaceholderStatus(args: {
+  intentId: string;
+  status:
+    | "NONE"
+    | "PENDING_PAYMENT"
+    | "PAYMENT_FAILED"
+    | "ON_RAMP_TRANSFER_COMPLETED";
+  purchaseData?: unknown;
+}): BuyWithFiatStatus {
+  const { intentId, status, purchaseData } = args;
+
+  // Build a minimal—but type-complete—object that satisfies BuyWithFiatStatus.
+  const emptyToken: PayTokenInfo = {
+    chainId: 0,
+    tokenAddress: "",
+    decimals: 18,
+    priceUSDCents: 0,
+    name: "",
+    symbol: "",
+  };
+
+  type BuyWithFiatStatusWithData = Exclude<
+    BuyWithFiatStatus,
+    { status: "NOT_FOUND" }
+  >;
+
+  const quote: BuyWithFiatStatusWithData["quote"] = {
+    estimatedOnRampAmount: "0",
+    estimatedOnRampAmountWei: "0",
+
+    estimatedToTokenAmount: "0",
+    estimatedToTokenAmountWei: "0",
+
+    fromCurrency: {
+      amount: "0",
+      amountUnits: "USD",
+      decimals: 2,
+      currencySymbol: "USD",
+    },
+    fromCurrencyWithFees: {
+      amount: "0",
+      amountUnits: "USD",
+      decimals: 2,
+      currencySymbol: "USD",
+    },
+    onRampToken: emptyToken,
+    toToken: emptyToken,
+    estimatedDurationSeconds: 0,
+    createdAt: new Date().toISOString(),
+  } as BuyWithFiatStatusWithData["quote"];
+
+  // The source/destination fields can only be filled accurately when extra context is returned
+  // by the API. Since Bridge.Onramp.status doesn't yet provide these details, we omit them for
+  // now (they are optional).
+
+  const base: Exclude<BuyWithFiatStatus, { status: "NOT_FOUND" }> = {
+    intentId,
+    status,
+    toAddress: "",
+    fromAddress: "",
+    quote,
+    purchaseData: purchaseData as object | undefined,
+  };
 
-    return (await response.json()).result;
-  } catch (error) {
-    console.error("Fetch error:", error);
-    throw new Error(`Fetch failed: ${error}`);
-  }
+  return base;
 }

package/src/pay/convert/cryptoToFiat.test.ts

@@ -1,10 +1,12 @@
 import { describe, expect, it, vi } from "vitest";
 import { TEST_CLIENT } from "~test/test-clients.js";
-import { TEST_ACCOUNT_A } from "~test/test-wallets.js";
 import { base } from "../../chains/chain-definitions/base.js";
 import { ethereum } from "../../chains/chain-definitions/ethereum.js";
 import { sepolia } from "../../chains/chain-definitions/sepolia.js";
-import { NATIVE_TOKEN_ADDRESS } from "../../constants/addresses.js";
+import {
+  NATIVE_TOKEN_ADDRESS,
+  ZERO_ADDRESS,
+} from "../../constants/addresses.js";
 import { convertCryptoToFiat } from "./cryptoToFiat.js";
 
 describe.runIf(process.env.TW_SECRET_KEY)("Pay: crypto-to-fiat", () => {
@@ -49,7 +51,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("Pay: crypto-to-fiat", () => {
     expect(data.result).toBe(0);
   });
 
-  it("should throw error for testnet chain (because testnets are not supported", async () => {
+  it("should throw error for testnet chain (because testnets are not supported)", async () => {
     await expect(
       convertCryptoToFiat({
         chain: sepolia,
@@ -81,13 +83,13 @@ describe.runIf(process.env.TW_SECRET_KEY)("Pay: crypto-to-fiat", () => {
     await expect(
       convertCryptoToFiat({
         chain: base,
-        fromTokenAddress: TEST_ACCOUNT_A.address,
+        fromTokenAddress: ZERO_ADDRESS,
         fromAmount: 1,
         to: "USD",
         client: TEST_CLIENT,
       }),
     ).rejects.toThrowError(
-      `Error: ${TEST_ACCOUNT_A.address} on chainId: ${base.id} is not a valid contract address.`,
+      `Error: ${ZERO_ADDRESS} on chainId: ${base.id} is not a valid contract address.`,
     );
   });
   it("should throw if response is not OK", async () => {