thirdweb 5.72.0-nightly-8aa454cbbbc2079749fa8250102ab0307d1b33af-20241202003724 → 5.73.0-nightly-ea855c66cb940d1adafefaad6dd689227701d277-20241203000359

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

@@ -0,0 +1,95 @@
+import { describe, expect, it } 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 { convertCryptoToFiat } from "./cryptoToFiat.js";
+
+describe.runIf(process.env.TW_SECRET_KEY)("Pay: crypto-to-fiat", () => {
+  it("should convert ETH price to USD on Ethereum mainnet", async () => {
+    const data = await convertCryptoToFiat({
+      chain: ethereum,
+      fromTokenAddress: NATIVE_TOKEN_ADDRESS,
+      fromAmount: 1,
+      to: "USD",
+      client: TEST_CLIENT,
+    });
+    expect(data.result).toBeDefined();
+    // Should be a number
+    expect(!Number.isNaN(data.result)).toBe(true);
+    // Since eth is around US$3000, we can add a test to check if the price is greater than $1500 (as a safe margin)
+    // let's hope that scenario does not happen :(
+    expect(Number(data.result) > 1500).toBe(true);
+  });
+
+  it("should convert ETH price to USD on Base mainnet", async () => {
+    const data = await convertCryptoToFiat({
+      chain: base,
+      fromTokenAddress: NATIVE_TOKEN_ADDRESS,
+      fromAmount: 1,
+      to: "USD",
+      client: TEST_CLIENT,
+    });
+    expect(data.result).toBeDefined();
+    // Should be a number
+    expect(!Number.isNaN(data.result)).toBe(true);
+    // Since eth is around US$3000, we can add a test to check if the price is greater than $1500 (as a safe margin)
+    // let's hope that scenario does not happen :(
+    expect(data.result > 1500).toBe(true);
+  });
+
+  it("should return zero if fromAmount is zero", async () => {
+    const data = await convertCryptoToFiat({
+      chain: base,
+      fromTokenAddress: NATIVE_TOKEN_ADDRESS,
+      fromAmount: 0,
+      to: "USD",
+      client: TEST_CLIENT,
+    });
+    expect(data.result).toBe(0);
+  });
+
+  it("should throw error for testnet chain (because testnets are not supported", async () => {
+    await expect(() =>
+      convertCryptoToFiat({
+        chain: sepolia,
+        fromTokenAddress: NATIVE_TOKEN_ADDRESS,
+        fromAmount: 1,
+        to: "USD",
+        client: TEST_CLIENT,
+      }),
+    ).rejects.toThrowError(
+      `Cannot fetch price for a testnet (chainId: ${sepolia.id})`,
+    );
+  });
+
+  it("should throw error if fromTokenAddress is set to an invalid EVM address", async () => {
+    await expect(() =>
+      convertCryptoToFiat({
+        chain: ethereum,
+        fromTokenAddress: "haha",
+        fromAmount: 1,
+        to: "USD",
+        client: TEST_CLIENT,
+      }),
+    ).rejects.toThrowError(
+      "Invalid fromTokenAddress. Expected a valid EVM contract address",
+    );
+  });
+
+  it("should throw error if fromTokenAddress is set to a wallet address", async () => {
+    await expect(() =>
+      convertCryptoToFiat({
+        chain: base,
+        fromTokenAddress: TEST_ACCOUNT_A.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.`,
+    );
+  });
+});

package/src/pay/convert/cryptoToFiat.ts

@@ -0,0 +1,111 @@
+import type { Address } from "abitype";
+import type { Chain } from "../../chains/types.js";
+import type { ThirdwebClient } from "../../client/client.js";
+import { NATIVE_TOKEN_ADDRESS } from "../../constants/addresses.js";
+import { getBytecode } from "../../contract/actions/get-bytecode.js";
+import { getContract } from "../../contract/contract.js";
+import { isAddress } from "../../utils/address.js";
+import { getClientFetch } from "../../utils/fetch.js";
+import { getPayConvertCryptoToFiatEndpoint } from "../utils/definitions.js";
+
+/**
+ * Props for the `convertCryptoToFiat` function
+ * @buyCrypto
+ */
+export type ConvertCryptoToFiatParams = {
+  client: ThirdwebClient;
+  /**
+   * The contract address of the token
+   * For native token, use NATIVE_TOKEN_ADDRESS
+   */
+  fromTokenAddress: Address;
+  /**
+   * The amount of token to convert to fiat value
+   */
+  fromAmount: number;
+  /**
+   * The chain that the token is deployed to
+   */
+  chain: Chain;
+  /**
+   * The fiat symbol. e.g "USD"
+   * Only USD is supported at the moment.
+   */
+  to: "USD";
+};
+
+/**
+ * Get a price of a token (using tokenAddress + chainId) in fiat.
+ * Only USD is supported at the moment.
+ * @example
+ * ### Basic usage
+ * For native token (non-ERC20), you should use NATIVE_TOKEN_ADDRESS as the value for `tokenAddress`
+ * ```ts
+ * import { convertCryptoToFiat } from "thirdweb/pay";
+ *
+ * // Get Ethereum price
+ * const result = convertCryptoToFiat({
+ *   fromTokenAddress: NATIVE_TOKEN_ADDRESS,
+ *   to: "USD",
+ *   chain: ethereum,
+ *   fromAmount: 1,
+ * });
+ *
+ * // Result: `{ result: 3404.11 }`
+ * ```
+ * @buyCrypto
+ * @returns a number representing the price (in selected fiat) of "x" token, with "x" being the `fromAmount`.
+ */
+export async function convertCryptoToFiat(
+  options: ConvertCryptoToFiatParams,
+): Promise<{ result: number }> {
+  const { client, fromTokenAddress, to, chain, fromAmount } = options;
+  if (Number(fromAmount) === 0) {
+    return { result: 0 };
+  }
+  // Testnets just don't work with our current provider(s)
+  if (chain.testnet === true) {
+    throw new Error(`Cannot fetch price for a testnet (chainId: ${chain.id})`);
+  }
+  // Some provider that we are using will return `0` for unsupported token
+  // so we should do some basic input validations before sending the request
+
+  // Make sure it's a valid EVM address
+  if (!isAddress(fromTokenAddress)) {
+    throw new Error(
+      "Invalid fromTokenAddress. Expected a valid EVM contract address",
+    );
+  }
+  // Make sure it's either a valid contract or a native token address
+  if (fromTokenAddress.toLowerCase() !== NATIVE_TOKEN_ADDRESS.toLowerCase()) {
+    const bytecode = await getBytecode(
+      getContract({
+        address: fromTokenAddress,
+        chain,
+        client,
+      }),
+    ).catch(() => undefined);
+    if (!bytecode || bytecode === "0x") {
+      throw new Error(
+        `Error: ${fromTokenAddress} on chainId: ${chain.id} is not a valid contract address.`,
+      );
+    }
+  }
+  const params = {
+    fromTokenAddress,
+    to,
+    chainId: String(chain.id),
+    fromAmount: String(fromAmount),
+  };
+  const queryString = new URLSearchParams(params).toString();
+  const url = `${getPayConvertCryptoToFiatEndpoint()}?${queryString}`;
+  const response = await getClientFetch(client)(url);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch ${to} value for token (${fromTokenAddress}) on chainId: ${chain.id}`,
+    );
+  }
+
+  const data: { result: number } = await response.json();
+  return data;
+}

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

@@ -0,0 +1,96 @@
+import { describe, expect, it } 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 { convertFiatToCrypto } from "./fiatToCrypto.js";
+
+describe.runIf(process.env.TW_SECRET_KEY)("Pay: fiatToCrypto", () => {
+  it("should convert fiat price to token on Ethereum mainnet", async () => {
+    const data = await convertFiatToCrypto({
+      chain: ethereum,
+      from: "USD",
+      fromAmount: 1,
+      to: NATIVE_TOKEN_ADDRESS,
+      client: TEST_CLIENT,
+    });
+    expect(data.result).toBeDefined();
+    // Should be a number
+    expect(!Number.isNaN(data.result)).toBe(true);
+    // Since eth is around US$3000, 1 USD should be around 0.0003
+    // we give it some safe margin so the test won't be flaky
+    expect(data.result < 0.001).toBe(true);
+  });
+
+  it("should convert fiat price to token on Base mainnet", async () => {
+    const data = await convertFiatToCrypto({
+      chain: base,
+      from: "USD",
+      fromAmount: 1,
+      to: NATIVE_TOKEN_ADDRESS,
+      client: TEST_CLIENT,
+    });
+
+    expect(data.result).toBeDefined();
+    // Should be a number
+    expect(!Number.isNaN(data.result)).toBe(true);
+    // Since eth is around US$3000, 1 USD should be around 0.0003
+    // we give it some safe margin so the test won't be flaky
+    expect(data.result < 0.001).toBe(true);
+  });
+
+  it("should return zero if the fromAmount is zero", async () => {
+    const data = await convertFiatToCrypto({
+      chain: base,
+      from: "USD",
+      fromAmount: 0,
+      to: NATIVE_TOKEN_ADDRESS,
+      client: TEST_CLIENT,
+    });
+    expect(data.result).toBe(0);
+  });
+
+  it("should throw error for testnet chain (because testnets are not supported", async () => {
+    await expect(() =>
+      convertFiatToCrypto({
+        chain: sepolia,
+        to: NATIVE_TOKEN_ADDRESS,
+        fromAmount: 1,
+        from: "USD",
+        client: TEST_CLIENT,
+      }),
+    ).rejects.toThrowError(
+      `Cannot fetch price for a testnet (chainId: ${sepolia.id})`,
+    );
+  });
+
+  it("should throw error if `to` is set to an invalid EVM address", async () => {
+    await expect(() =>
+      convertFiatToCrypto({
+        chain: ethereum,
+        to: "haha",
+        fromAmount: 1,
+        from: "USD",
+        client: TEST_CLIENT,
+      }),
+    ).rejects.toThrowError(
+      "Invalid `to`. Expected a valid EVM contract address",
+    );
+  });
+
+  it("should throw error if `to` is set to a wallet address", async () => {
+    await expect(() =>
+      convertFiatToCrypto({
+        chain: base,
+        to: TEST_ACCOUNT_A.address,
+        fromAmount: 1,
+        from: "USD",
+        client: TEST_CLIENT,
+      }),
+    ).rejects.toThrowError(
+      `Error: ${TEST_ACCOUNT_A.address} on chainId: ${base.id} is not a valid contract address.`,
+    );
+  });
+});

package/src/pay/convert/fiatToCrypto.ts

@@ -0,0 +1,110 @@
+import type { Address } from "abitype";
+import type { Chain } from "../../chains/types.js";
+import type { ThirdwebClient } from "../../client/client.js";
+import { NATIVE_TOKEN_ADDRESS } from "../../constants/addresses.js";
+import { getBytecode } from "../../contract/actions/get-bytecode.js";
+import { getContract } from "../../contract/contract.js";
+import { isAddress } from "../../utils/address.js";
+import { getClientFetch } from "../../utils/fetch.js";
+import { getPayConvertFiatToCryptoEndpoint } from "../utils/definitions.js";
+
+/**
+ * Props for the `convertFiatToCrypto` function
+ * @buyCrypto
+ */
+export type ConvertFiatToCryptoParams = {
+  client: ThirdwebClient;
+  /**
+   * The fiat symbol. e.g: "USD"
+   * Currently only USD is supported.
+   */
+  from: "USD";
+  /**
+   * The total amount of fiat to convert
+   * e.g: If you want to convert 2 cents to USD, enter `0.02`
+   */
+  fromAmount: number;
+  /**
+   * The token address
+   * For native token, use NATIVE_TOKEN_ADDRESS
+   */
+  to: Address;
+  /**
+   * The chain that the token is deployed to
+   */
+  chain: Chain;
+};
+
+/**
+ * Convert a fiat value to a token.
+ * Currently only USD is supported.
+ * @example
+ * ### Basic usage
+ * ```ts
+ * import { convertFiatToCrypto } from "thirdweb/pay";
+ *
+ * // Convert 2 cents to ETH
+ * const result = await convertFiatToCrypto({
+ *   from: "USD",
+ *   // the token address. For native token, use NATIVE_TOKEN_ADDRESS
+ *   to: "0x...",
+ *   // the chain (of the chain where the token belong to)
+ *   chain: ethereum,
+ *   // 2 cents
+ *   fromAmount: 0.02,
+ * });
+ * ```
+ * Result: `{ result: 0.0000057 }`
+ * @buyCrypto
+ */
+export async function convertFiatToCrypto(
+  options: ConvertFiatToCryptoParams,
+): Promise<{ result: number }> {
+  const { client, from, to, chain, fromAmount } = options;
+  if (Number(fromAmount) === 0) {
+    return { result: 0 };
+  }
+  // Testnets just don't work with our current provider(s)
+  if (chain.testnet === true) {
+    throw new Error(`Cannot fetch price for a testnet (chainId: ${chain.id})`);
+  }
+  // Some provider that we are using will return `0` for unsupported token
+  // so we should do some basic input validations before sending the request
+
+  // Make sure it's a valid EVM address
+  if (!isAddress(to)) {
+    throw new Error("Invalid `to`. Expected a valid EVM contract address");
+  }
+  // Make sure it's either a valid contract or a native token
+  if (to.toLowerCase() !== NATIVE_TOKEN_ADDRESS.toLowerCase()) {
+    const bytecode = await getBytecode(
+      getContract({
+        address: to,
+        chain,
+        client,
+      }),
+    ).catch(() => undefined);
+    if (!bytecode || bytecode === "0x") {
+      throw new Error(
+        `Error: ${to} on chainId: ${chain.id} is not a valid contract address.`,
+      );
+    }
+  }
+  const params = {
+    from,
+    to,
+    chainId: String(chain.id),
+    fromAmount: String(fromAmount),
+  };
+  const queryString = new URLSearchParams(params).toString();
+  const url = `${getPayConvertFiatToCryptoEndpoint()}?${queryString}`;
+  const response = await getClientFetch(client)(url);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to convert ${to} value to token (${to}) on chainId: ${chain.id}`,
+    );
+  }
+
+  const data: { result: number } = await response.json();
+  return data;
+}

package/src/pay/utils/definitions.ts

@@ -76,3 +76,9 @@ export const getPaySupportedSources = () =>
  */
 export const getPayBuyHistoryEndpoint = () =>
   `${getPayBaseUrl()}/wallet/history/v1`;
+
+export const getPayConvertFiatToCryptoEndpoint = () =>
+  `${getPayBaseUrl()}/convert/fiat-to-crypto/v1`;
+
+export const getPayConvertCryptoToFiatEndpoint = () =>
+  `${getPayBaseUrl()}/convert/crypto-to-fiat/v1`;

package/src/react/core/hooks/transaction/useSendTransaction.ts

@@ -1,14 +1,13 @@
 import { type UseMutationResult, useMutation } from "@tanstack/react-query";
 import type { Chain } from "../../../../chains/types.js";
-import { getGasPrice } from "../../../../gas/get-gas-price.js";
 import type { BuyWithCryptoStatus } from "../../../../pay/buyWithCrypto/getStatus.js";
 import type { BuyWithFiatStatus } from "../../../../pay/buyWithFiat/getStatus.js";
 import type { FiatProvider } from "../../../../pay/utils/commonTypes.js";
-import { estimateGasCost } from "../../../../transaction/actions/estimate-gas-cost.js";
 import type { GaslessOptions } from "../../../../transaction/actions/gasless/types.js";
 import { sendTransaction } from "../../../../transaction/actions/send-transaction.js";
 import type { WaitForReceiptOptions } from "../../../../transaction/actions/wait-for-tx-receipt.js";
 import type { PreparedTransaction } from "../../../../transaction/prepare-transaction.js";
+import { getTransactionGasCost } from "../../../../transaction/utils.js";
 import { resolvePromisedValue } from "../../../../utils/promise/resolve-promised-value.js";
 import type { Wallet } from "../../../../wallets/interfaces/wallet.js";
 import { getTokenBalance } from "../../../../wallets/utils/getTokenBalance.js";
@@ -215,7 +214,7 @@ export function useSendTransactionCore(args: {
                     tokenAddress: _erc20Value.tokenAddress,
                   })
                 : undefined,
-              getTotalTxCostForBuy(tx, account.address),
+              getTransactionGasCost(tx, account.address),
             ]);
 
             const gasSponsored = hasSponsoredTransactionsEnabled(wallet);
@@ -248,39 +247,3 @@ export function useSendTransactionCore(args: {
     },
   });
 }
-
-async function getTotalTxCostForBuy(tx: PreparedTransaction, from?: string) {
-  try {
-    const gasCost = await estimateGasCost({
-      transaction: tx,
-      from,
-    });
-
-    const bufferCost = gasCost.wei / 10n;
-
-    // Note: get tx.value AFTER estimateGasCost
-    const txValue = await resolvePromisedValue(tx.value);
-
-    // add 10% extra gas cost to the estimate to ensure user buys enough to cover the tx cost
-    return gasCost.wei + bufferCost + (txValue || 0n);
-  } catch {
-    if (from) {
-      // try again without passing from
-      return await getTotalTxCostForBuy(tx);
-    }
-    // fallback if both fail, use the tx value + 2M * gas price
-    const value = await resolvePromisedValue(tx.value);
-
-    const gasPrice = await getGasPrice({
-      client: tx.client,
-      chain: tx.chain,
-    });
-
-    const buffer = 2_000_000n * gasPrice;
-
-    if (!value) {
-      return 0n + buffer;
-    }
-    return value + buffer;
-  }
-}

package/src/react/web/ui/ConnectWallet/screens/Buy/main/useBuyTxStates.ts

@@ -4,10 +4,9 @@ import { getChainMetadata } from "../../../../../../../chains/utils.js";
 import { NATIVE_TOKEN_ADDRESS } from "../../../../../../../constants/addresses.js";
 import { getContract } from "../../../../../../../contract/contract.js";
 import { getCurrencyMetadata } from "../../../../../../../extensions/erc20/read/getCurrencyMetadata.js";
-import { getGasPrice } from "../../../../../../../gas/get-gas-price.js";
 import { encode } from "../../../../../../../transaction/actions/encode.js";
-import { estimateGasCost } from "../../../../../../../transaction/actions/estimate-gas-cost.js";
 import type { PreparedTransaction } from "../../../../../../../transaction/prepare-transaction.js";
+import { getTransactionGasCost } from "../../../../../../../transaction/utils.js";
 import type { Hex } from "../../../../../../../utils/encoding/hex.js";
 import { resolvePromisedValue } from "../../../../../../../utils/promise/resolve-promised-value.js";
 import type { Account } from "../../../../../../../wallets/interfaces/wallet.js";
@@ -138,30 +137,3 @@ export function useTransactionCostAndData(args: {
     },
   });
 }
-
-async function getTransactionGasCost(tx: PreparedTransaction, from?: string) {
-  try {
-    const gasCost = await estimateGasCost({
-      transaction: tx,
-      from,
-    });
-
-    const bufferCost = gasCost.wei / 10n;
-
-    // Note: get tx.value AFTER estimateGasCost
-    // add 10% extra gas cost to the estimate to ensure user buys enough to cover the tx cost
-    return gasCost.wei + bufferCost;
-  } catch {
-    if (from) {
-      // try again without passing from
-      return await getTransactionGasCost(tx);
-    }
-    // fallback if both fail, use the tx value + 2M * gas price
-    const gasPrice = await getGasPrice({
-      client: tx.client,
-      chain: tx.chain,
-    });
-
-    return 2_000_000n * gasPrice;
-  }
-}

package/src/transaction/actions/zksync/send-eip712-transaction.ts

@@ -173,7 +173,11 @@ export async function getZkGasFees(args: {
     resolvePromisedValue(transaction.eip712),
   ]);
   let gasPerPubdata = eip712?.gasPerPubdata;
-  if (!gas || !maxFeePerGas || !maxPriorityFeePerGas) {
+  if (
+    gas === undefined ||
+    maxFeePerGas === undefined ||
+    maxPriorityFeePerGas === undefined
+  ) {
     const rpc = getRpcClient(transaction);
     const params = await formatTransaction({ transaction, from });
     const result = (await rpc({

package/src/transaction/utils.ts

@@ -1,4 +1,7 @@
 import type { AbiFunction } from "abitype";
+import { getGasPrice } from "../gas/get-gas-price.js";
+import { estimateGasCost } from "./actions/estimate-gas-cost.js";
+import type { PreparedTransaction } from "./prepare-transaction.js";
 
 /**
  * @internal
@@ -11,3 +14,33 @@ export function isAbiFunction(item: unknown): item is AbiFunction {
     item.type === "function"
   );
 }
+
+export async function getTransactionGasCost(
+  tx: PreparedTransaction,
+  from?: string,
+) {
+  try {
+    const gasCost = await estimateGasCost({
+      transaction: tx,
+      from,
+    });
+
+    const bufferCost = gasCost.wei / 10n;
+
+    // Note: get tx.value AFTER estimateGasCost
+    // add 10% extra gas cost to the estimate to ensure user buys enough to cover the tx cost
+    return gasCost.wei + bufferCost;
+  } catch {
+    if (from) {
+      // try again without passing from
+      return await getTransactionGasCost(tx);
+    }
+    // fallback if both fail, use the tx value + 1M * gas price
+    const gasPrice = await getGasPrice({
+      client: tx.client,
+      chain: tx.chain,
+    });
+
+    return 1_000_000n * gasPrice;
+  }
+}

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.72.0-nightly-8aa454cbbbc2079749fa8250102ab0307d1b33af-20241202003724";
+export const version = "5.73.0-nightly-ea855c66cb940d1adafefaad6dd689227701d277-20241203000359";