thirdweb 5.99.2 → 5.100.0-nightly-713ebe0a2d6d8a409e41ce0f0317fc34b1f221bb-20250520000414

package/src/pay/buyWithCrypto/getQuote.ts

@@ -1,15 +1,16 @@
-import type { Hash } from "viem";
+import { Value } from "ox";
+import * as ox__AbiFunction from "ox/AbiFunction";
+import * as Bridge 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 { getClientFetch } from "../../utils/fetch.js";
-import { stringify } from "../../utils/json.js";
-import { getPayBuyWithCryptoQuoteEndpoint } from "../utils/definitions.js";
 import type {
   QuoteApprovalInfo,
   QuotePaymentToken,
   QuoteTokenInfo,
-  QuoteTransactionRequest,
 } from "./commonTypes.js";
 
 /**
@@ -105,44 +106,6 @@ export type GetBuyWithCryptoQuoteParams = {
     }
 );
 
-/**
- * @buyCrypto
- */
-type BuyWithCryptoQuoteRouteResponse = {
-  transactionRequest: QuoteTransactionRequest;
-  approval?: QuoteApprovalInfo;
-
-  fromAddress: string;
-  toAddress: string;
-
-  fromToken: QuoteTokenInfo;
-  toToken: QuoteTokenInfo;
-
-  fromAmountWei: string;
-  fromAmount: string;
-
-  toAmountMinWei: string;
-  toAmountMin: string;
-  toAmountWei: string;
-  toAmount: string;
-
-  paymentTokens: QuotePaymentToken[];
-  processingFees: QuotePaymentToken[];
-
-  estimated: {
-    fromAmountUSDCents: number;
-    toAmountMinUSDCents: number;
-    toAmountUSDCents: number;
-    slippageBPS: number;
-    feesUSDCents: number;
-    gasCostUSDCents?: number;
-    durationSeconds?: number;
-  };
-
-  maxSlippageBPS: number;
-  bridge?: string;
-};
-
 /**
  * @buyCrypto
  */
@@ -215,76 +178,223 @@ export async function getBuyWithCryptoQuote(
   params: GetBuyWithCryptoQuoteParams,
 ): Promise<BuyWithCryptoQuote> {
   try {
-    const clientFetch = getClientFetch(params.client);
-
-    const response = await clientFetch(getPayBuyWithCryptoQuoteEndpoint(), {
-      method: "POST",
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json",
-      },
-      body: stringify({
-        fromAddress: params.fromAddress,
-        toAddress: params.toAddress,
-        fromChainId: params.fromChainId.toString(),
-        fromTokenAddress: params.fromTokenAddress,
-        toChainId: params.toChainId.toString(),
-        toTokenAddress: params.toTokenAddress,
-        fromAmount: params.fromAmount,
-        toAmount: params.toAmount,
-        maxSlippageBPS: params.maxSlippageBPS,
-        intentId: params.intentId,
-        purchaseData: params.purchaseData,
-      }),
-    });
-
-    // Assuming the response directly matches the SwapResponse interface
-    if (!response.ok) {
-      const errorObj = await response.json();
-      if (errorObj && "error" in errorObj) {
-        throw errorObj;
+    const quote = await (async () => {
+      if (params.toAmount) {
+        const destinationTokenContract = getContract({
+          address: params.toTokenAddress,
+          chain: getCachedChain(params.toChainId),
+          client: params.client,
+        });
+        const tokenDecimals =
+          destinationTokenContract.address.toLowerCase() ===
+          NATIVE_TOKEN_ADDRESS
+            ? 18
+            : await decimals({
+                contract: destinationTokenContract,
+              });
+        const amount = Value.from(params.toAmount, tokenDecimals);
+        return Bridge.Buy.prepare({
+          sender: params.fromAddress,
+          receiver: params.toAddress,
+          originChainId: params.fromChainId,
+          originTokenAddress: params.fromTokenAddress,
+          destinationChainId: params.toChainId,
+          destinationTokenAddress: params.toTokenAddress,
+          amount: amount,
+          purchaseData: params.purchaseData,
+          client: params.client,
+        });
+      } else if (params.fromAmount) {
+        const originTokenContract = getContract({
+          address: params.fromTokenAddress,
+          chain: getCachedChain(params.fromChainId),
+          client: params.client,
+        });
+        const tokenDecimals = await decimals({
+          contract: originTokenContract,
+        });
+        const amount = Value.from(params.fromAmount, tokenDecimals);
+        return Bridge.Sell.prepare({
+          sender: params.fromAddress,
+          receiver: params.toAddress,
+          originChainId: params.fromChainId,
+          originTokenAddress: params.fromTokenAddress,
+          destinationChainId: params.toChainId,
+          destinationTokenAddress: params.toTokenAddress,
+          amount: amount,
+          purchaseData: params.purchaseData,
+          client: params.client,
+        });
       }
-      throw new Error(`HTTP error! status: ${response.status}`);
+      throw new Error(
+        "Invalid quote request, must provide either `fromAmount` or `toAmount`",
+      );
+    })();
+
+    // check if the fromAddress already has approval for the given amount
+    const firstStep = quote.steps[0];
+    if (!firstStep) {
+      throw new Error(
+        "This quote is incompatible with getBuyWithCryptoQuote. Please use Bridge.Buy.prepare instead.",
+      );
+    }
+    const approvalTxs = firstStep.transactions.filter(
+      (tx) => tx.action === "approval",
+    );
+    if (approvalTxs.length > 1) {
+      throw new Error(
+        "This quote is incompatible with getBuyWithCryptoQuote. Please use Bridge.Buy.prepare instead.",
+      );
     }
+    const approvalTx = approvalTxs[0];
 
-    const data: BuyWithCryptoQuoteRouteResponse = (await response.json())
-      .result;
+    const txs = firstStep.transactions.filter((tx) => tx.action !== "approval");
+    if (txs.length > 1) {
+      throw new Error(
+        "This quote is incompatible with getBuyWithCryptoQuote. Please use Bridge.Buy.prepare instead.",
+      );
+    }
+    const tx = txs[0];
+    if (!tx) {
+      throw new Error(
+        "This quote is incompatible with getBuyWithCryptoQuote. Please use Bridge.Buy.prepare instead.",
+      );
+    }
 
-    // check if the fromAddress already has approval for the given amount
-    const approvalData = data.approval;
+    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 swapRoute: BuyWithCryptoQuote = {
       transactionRequest: {
-        chain: getCachedChain(data.transactionRequest.chainId),
-        client: params.client,
-        data: data.transactionRequest.data as Hash,
-        to: data.transactionRequest.to,
-        value: BigInt(data.transactionRequest.value),
+        ...tx,
         extraGas: 50000n, // extra gas buffer
       },
       approvalData,
       swapDetails: {
-        fromAddress: data.fromAddress,
-        toAddress: data.toAddress,
-
-        fromToken: data.fromToken,
-        toToken: data.toToken,
-
-        fromAmount: data.fromAmount,
-        fromAmountWei: data.fromAmountWei,
-
-        toAmountMinWei: data.toAmountMinWei,
-        toAmountMin: data.toAmountMin,
-
-        toAmountWei: data.toAmountWei,
-        toAmount: data.toAmount,
-        estimated: data.estimated,
-
-        maxSlippageBPS: data.maxSlippageBPS,
+        fromAddress: quote.intent.sender,
+        toAddress: quote.intent.receiver,
+
+        fromToken: {
+          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,
+        },
+        toToken: {
+          tokenAddress: firstStep.destinationToken.address,
+          chainId: firstStep.destinationToken.chainId,
+          decimals: firstStep.destinationToken.decimals,
+          symbol: firstStep.destinationToken.symbol,
+          name: firstStep.destinationToken.name,
+          priceUSDCents: firstStep.destinationToken.priceUsd * 100,
+        },
+
+        fromAmount: Value.format(
+          quote.originAmount,
+          firstStep.originToken.decimals,
+        ).toString(),
+        fromAmountWei: quote.originAmount.toString(),
+
+        toAmountMinWei: quote.destinationAmount.toString(),
+        toAmountMin: Value.format(
+          quote.destinationAmount,
+          firstStep.destinationToken.decimals,
+        ).toString(),
+
+        toAmountWei: quote.destinationAmount.toString(),
+        toAmount: Value.format(
+          quote.destinationAmount,
+          firstStep.destinationToken.decimals,
+        ).toString(),
+        estimated: {
+          fromAmountUSDCents:
+            Number(
+              Value.format(quote.originAmount, firstStep.originToken.decimals),
+            ) *
+            firstStep.originToken.priceUsd *
+            100,
+          toAmountMinUSDCents:
+            Number(
+              Value.format(
+                quote.destinationAmount,
+                firstStep.destinationToken.decimals,
+              ),
+            ) *
+            firstStep.destinationToken.priceUsd *
+            100,
+          toAmountUSDCents:
+            Number(
+              Value.format(
+                quote.destinationAmount,
+                firstStep.destinationToken.decimals,
+              ),
+            ) *
+            firstStep.destinationToken.priceUsd *
+            100,
+          slippageBPS: 0,
+          feesUSDCents: 0,
+          gasCostUSDCents: 0,
+          durationSeconds: firstStep.estimatedExecutionTimeMs / 1000,
+        },
+
+        maxSlippageBPS: 0,
       },
 
-      paymentTokens: data.paymentTokens,
-      processingFees: data.processingFees,
+      paymentTokens: [
+        {
+          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,
+        },
+      ],
+      // TODO (UB): add develope and platform fees in API
+      processingFees: [
+        {
+          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,
+          },
+          amountUSDCents: 0,
+          amountWei: "0",
+          amount: "0",
+        },
+      ],
       client: params.client,
     };
 

package/src/pay/buyWithCrypto/getStatus.ts

@@ -1,10 +1,12 @@
+import { type Status, status as bridgeStatus } from "../../bridge/index.js";
+import type { Token } from "../../bridge/types/Token.js";
 import type { ThirdwebClient } from "../../client/client.js";
-import { getClientFetch } from "../../utils/fetch.js";
+import type { Hex } from "../../utils/encoding/hex.js";
+import { toTokens } from "../../utils/units.js";
 import type {
   PayOnChainTransactionDetails,
   PayTokenInfo,
 } from "../utils/commonTypes.js";
-import { getPayBuyWithCryptoStatusUrl } from "../utils/definitions.js";
 
 // TODO: add JSDoc description for all properties
 
@@ -123,7 +125,7 @@ export type ValidBuyWithCryptoStatus = Exclude<
  * }});
  * ```
  * @returns Object of type [`BuyWithCryptoStatus`](https://portal.thirdweb.com/references/typescript/v5/BuyWithCryptoStatus)
- * @deprecated
+ * @deprecated use Bridge.status instead
  * @buyCrypto
  */
 export async function getBuyWithCryptoStatus(
@@ -133,26 +135,217 @@ export async function getBuyWithCryptoStatus(
     if (!buyWithCryptoTransaction.transactionHash) {
       throw new Error("Transaction hash is required");
     }
-    const queryString = new URLSearchParams({
-      transactionHash: buyWithCryptoTransaction.transactionHash,
-      chainId: buyWithCryptoTransaction.chainId.toString(),
-    }).toString();
-    const url = `${getPayBuyWithCryptoStatusUrl()}?${queryString}`;
-
-    const response = await getClientFetch(buyWithCryptoTransaction.client)(url);
-
-    // Assuming the response directly matches the BuyWithCryptoStatus interface
-    if (!response.ok) {
-      const error = await response.text().catch(() => null);
-      throw new Error(
-        `HTTP error! status: ${response.status} - ${response.statusText}: ${error || "unknown error"}`,
-      );
-    }
+    const result = await bridgeStatus({
+      transactionHash: buyWithCryptoTransaction.transactionHash as Hex,
+      chainId: buyWithCryptoTransaction.chainId,
+      client: buyWithCryptoTransaction.client,
+    });
+
+    switch (result.status) {
+      case "COMPLETED": {
+        const originTransaction = result.transactions?.find(
+          (tx) => tx.chainId === buyWithCryptoTransaction.chainId,
+        );
+        const destinationTransaction = result.transactions?.find(
+          (tx) => tx.chainId !== buyWithCryptoTransaction.chainId,
+        );
 
-    const data: BuyWithCryptoStatus = (await response.json()).result;
-    return data;
+        return toBuyWithCryptoStatus({
+          originTransaction,
+          destinationTransaction,
+          originAmount: result.originAmount,
+          destinationAmount: result.destinationAmount,
+          originTokenAddress: result.originTokenAddress,
+          destinationTokenAddress: result.destinationTokenAddress,
+          originChainId: result.originChainId,
+          destinationChainId: result.destinationChainId,
+          status: result.status,
+          sender: result.sender,
+          receiver: result.receiver,
+          paymentId: result.paymentId,
+          originToken: result.originToken,
+          destinationToken: result.destinationToken,
+          purchaseData: result.purchaseData as object | undefined,
+        });
+      }
+      case "PENDING": {
+        return toBuyWithCryptoStatus({
+          originAmount: result.originAmount,
+          originTokenAddress: result.originTokenAddress,
+          destinationTokenAddress: result.destinationTokenAddress,
+          originChainId: result.originChainId,
+          destinationChainId: result.destinationChainId,
+          status: result.status,
+          sender: result.sender,
+          receiver: result.receiver,
+          paymentId: result.paymentId,
+          originToken: result.originToken,
+          destinationToken: result.destinationToken,
+          purchaseData: result.purchaseData as object | undefined,
+        });
+      }
+      case "FAILED": {
+        const originTransaction = result.transactions?.find(
+          (tx) => tx.chainId === buyWithCryptoTransaction.chainId,
+        );
+        const destinationTransaction = result.transactions?.find(
+          (tx) => tx.chainId !== buyWithCryptoTransaction.chainId,
+        );
+        return toBuyWithCryptoStatus({
+          originTransaction,
+          destinationTransaction,
+          originAmount: BigInt(0), // TODO: get from API
+          originTokenAddress: "", // TODO: get from API
+          destinationTokenAddress: "", // TODO: get from API
+          originChainId: 0, // TODO: get from API
+          destinationChainId: 0, // TODO: get from API
+          status: result.status,
+          sender: "",
+          receiver: "",
+          paymentId: "",
+          originToken: undefined,
+          destinationToken: undefined,
+          purchaseData: result.purchaseData as object | undefined,
+        });
+      }
+      default: {
+        return {
+          status: "NOT_FOUND",
+        };
+      }
+    }
   } catch (error) {
     console.error("Fetch error:", error);
     throw new Error(`Fetch failed: ${error}`);
   }
 }
+
+function toBuyWithCryptoStatus(args: {
+  originTransaction?: Status["transactions"][number];
+  destinationTransaction?: Status["transactions"][number];
+  originAmount: bigint;
+  originTokenAddress: string;
+  destinationAmount?: bigint;
+  destinationTokenAddress: string;
+  originChainId: number;
+  destinationChainId: number;
+  status: Status["status"];
+  purchaseData?: object;
+  sender: string;
+  receiver: string;
+  paymentId: string;
+  originToken?: Token;
+  destinationToken?: Token;
+}): BuyWithCryptoStatus {
+  const {
+    originTransaction,
+    destinationTransaction,
+    status,
+    purchaseData,
+    originAmount,
+    destinationAmount,
+    originTokenAddress,
+    destinationTokenAddress,
+    originChainId,
+    destinationChainId,
+    sender,
+    receiver,
+    originToken,
+    destinationToken,
+  } = args;
+  return {
+    fromAddress: sender,
+    toAddress: receiver,
+    quote: {
+      createdAt: new Date().toISOString(),
+      estimated: {
+        fromAmountUSDCents: 0,
+        toAmountMinUSDCents: 0,
+        toAmountUSDCents: 0,
+        slippageBPS: 0,
+        feesUSDCents: 0,
+        gasCostUSDCents: 0,
+        durationSeconds: 0,
+      },
+      fromAmount: originToken
+        ? toTokens(originAmount, originToken.decimals).toString()
+        : "",
+      fromAmountWei: originAmount.toString(),
+      toAmount:
+        destinationToken && destinationAmount
+          ? toTokens(destinationAmount, destinationToken.decimals).toString()
+          : "",
+      toAmountWei: destinationAmount ? destinationAmount.toString() : "",
+      toAmountMin: destinationToken
+        ? toTokens(
+            destinationAmount ?? BigInt(0),
+            destinationToken.decimals,
+          ).toString()
+        : "",
+      toAmountMinWei: destinationAmount ? destinationAmount.toString() : "",
+      fromToken: {
+        tokenAddress: originTokenAddress,
+        chainId: originChainId,
+        decimals: originToken?.decimals ?? 18,
+        name: originToken?.name ?? "",
+        symbol: originToken?.symbol ?? "",
+        priceUSDCents: 0,
+      },
+      toToken: {
+        tokenAddress: destinationTokenAddress,
+        chainId: destinationChainId,
+        decimals: destinationToken?.decimals ?? 18,
+        name: destinationToken?.name ?? "",
+        symbol: destinationToken?.symbol ?? "",
+        priceUSDCents: 0,
+      },
+    },
+    swapType:
+      originTransaction?.chainId === destinationTransaction?.chainId
+        ? "SAME_CHAIN"
+        : "CROSS_CHAIN", // TODO transfer type?
+    status: status,
+    subStatus: status === "COMPLETED" ? "SUCCESS" : "NONE",
+    purchaseData: purchaseData as object | undefined,
+    bridge: "STARPORT",
+    destination: {
+      amount: destinationToken
+        ? toTokens(
+            destinationAmount ?? BigInt(0),
+            destinationToken.decimals,
+          ).toString()
+        : "",
+      amountWei: destinationAmount?.toString() ?? "",
+      token: {
+        tokenAddress: destinationTokenAddress,
+        chainId: destinationChainId,
+        decimals: destinationToken?.decimals ?? 18,
+        name: destinationToken?.name ?? "",
+        symbol: destinationToken?.symbol ?? "",
+        priceUSDCents: 0,
+      },
+      amountUSDCents: 0,
+      completedAt: new Date().toISOString(),
+      explorerLink: "",
+      transactionHash: destinationTransaction?.transactionHash ?? "",
+    },
+    source: {
+      amount: originToken
+        ? toTokens(originAmount, originToken.decimals).toString()
+        : "",
+      amountWei: originAmount.toString(),
+      token: {
+        tokenAddress: originTokenAddress,
+        chainId: originChainId,
+        decimals: originToken?.decimals ?? 18,
+        name: originToken?.name ?? "",
+        symbol: originToken?.symbol ?? "",
+        priceUSDCents: 0,
+      },
+      amountUSDCents: 0,
+      completedAt: new Date().toISOString(),
+      explorerLink: "",
+      transactionHash: originTransaction?.transactionHash ?? "",
+    },
+  };
+}