thirdweb 5.99.3 → 5.100.0

package/src/bridge/Onramp.ts

@@ -0,0 +1,244 @@
+import type { Address as ox__Address } from "ox";
+import type { ThirdwebClient } from "../client/client.js";
+import { getThirdwebBaseUrl } from "../utils/domains.js";
+import { getClientFetch } from "../utils/fetch.js";
+import { stringify } from "../utils/json.js";
+import type { RouteStep } from "./types/Route.js";
+import type { Token } from "./types/Token.js";
+
+// export status within the Onramp module
+export { status } from "./OnrampStatus.js";
+
+type OnrampIntent = {
+  onramp: "stripe" | "coinbase" | "transak";
+  chainId: number;
+  tokenAddress: ox__Address.Address;
+  receiver: ox__Address.Address;
+  amount?: string; // Corresponds to buyAmountWei in some other contexts
+  purchaseData?: unknown;
+  sender?: ox__Address.Address;
+  onrampTokenAddress?: ox__Address.Address;
+  onrampChainId?: number;
+  currency?: string;
+  maxSteps?: number;
+  excludeChainIds?: string | string[];
+};
+
+type OnrampPrepareQuoteResponseData = {
+  id: string;
+  link: string;
+  currency: string;
+  currencyAmount: number;
+  destinationAmount: bigint;
+  destinationToken: Token;
+  timestamp?: number;
+  expiration?: number;
+  steps: RouteStep[];
+  intent: OnrampIntent;
+};
+
+// Explicit type for the API request body
+interface OnrampApiRequestBody {
+  onramp: "stripe" | "coinbase" | "transak";
+  chainId: number;
+  tokenAddress: ox__Address.Address;
+  receiver: ox__Address.Address;
+  amount?: string;
+  purchaseData?: unknown;
+  sender?: ox__Address.Address;
+  onrampTokenAddress?: ox__Address.Address;
+  onrampChainId?: number;
+  currency?: string;
+  maxSteps?: number;
+  excludeChainIds?: string;
+}
+
+/**
+ * Prepares an onramp transaction, returning a link from the specified provider to onramp to the specified token.
+ *
+ * @example
+ * ```typescript
+ * import { Bridge } from "thirdweb";
+ * import { ethereum } from "thirdweb/chains";
+ * import { NATIVE_TOKEN_ADDRESS, toWei } from "thirdweb/utils";
+ *
+ * const preparedOnramp = await Bridge.Onramp.prepare({
+ *   client: thirdwebClient,
+ *   onramp: "stripe",
+ *   chainId: ethereum.id,
+ *   tokenAddress: NATIVE_TOKEN_ADDRESS,
+ *   receiver: "0x...", // receiver's address
+ *   amount: toWei("10"), // 10 of the destination token
+ *   // Optional params:
+ *   // sender: "0x...", // sender's address
+ *   // onrampTokenAddress: NATIVE_TOKEN_ADDRESS, // token to initially onramp to
+ *   // onrampChainId: 1, // chain to initially onramp to
+ *   // currency: "USD",
+ *   // maxSteps: 2,
+ *   // purchaseData: { customId: "123" }
+ * });
+ *
+ * console.log(preparedOnramp.link); // URL to redirect the user to
+ * console.log(preparedOnramp.currencyAmount); // Amount in fiat the user will pay
+ * ```
+ *
+ * This function returns a quote that might look like:
+ * ```typescript
+ * {
+ *   id: "123e4567-e89b-12d3-a456-426614174000",
+ *   link: "https://onramp.example.com/session?id=...",
+ *   currency: "USD",
+ *   currencyAmount: 10.52,
+ *   destinationAmount: 10000000000000000000n, // 10 ETH if decimals 18
+ *   timestamp: 1689812800,
+ *   expiration: 1689842800,
+ *   steps: [
+ *     // ... further steps if any post-onramp swaps are needed
+ *   ],
+ *   intent: {
+ *     onramp: "stripe",
+ *     chainId: 1,
+ *     tokenAddress: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+ *     receiver: "0x...",
+ *     amount: "10000000000000000000"
+ *   }
+ * }
+ * ```
+ *
+ * @param options - The options for preparing the onramp.
+ * @param options.client - Your thirdweb client.
+ * @param options.onramp - The onramp provider to use (e.g., "stripe", "coinbase", "transak").
+ * @param options.chainId - The destination chain ID.
+ * @param options.tokenAddress - The destination token address.
+ * @param options.receiver - The address that will receive the output token.
+ * @param [options.amount] - The desired token amount in wei.
+ * @param [options.purchaseData] - Arbitrary purchase data.
+ * @param [options.sender] - An optional address to associate as the onramp sender.
+ * @param [options.onrampTokenAddress] - The token to initially onramp to if the destination token is not supported by the provider.
+ * @param [options.onrampChainId] - The chain ID to initially onramp to if the destination chain is not supported.
+ * @param [options.currency] - The currency for the onramp (e.g., "USD", "GBP"). Defaults to user's preferred or "USD".
+ * @param [options.maxSteps] - Maximum number of post-onramp steps.
+ * @param [options.excludeChainIds] - Chain IDs to exclude from the route (string or array of strings).
+ *
+ * @returns A promise that resolves to the prepared onramp details, including the link and quote.
+ * @throws Will throw an error if there is an issue preparing the onramp.
+ * @bridge Onramp
+ * @beta
+ */
+export async function prepare(
+  options: prepare.Options,
+): Promise<prepare.Result> {
+  const {
+    client,
+    onramp,
+    chainId,
+    tokenAddress,
+    receiver,
+    amount,
+    purchaseData,
+    sender,
+    onrampTokenAddress,
+    onrampChainId,
+    currency,
+    maxSteps,
+    excludeChainIds,
+  } = options;
+
+  const clientFetch = getClientFetch(client);
+  const url = `${getThirdwebBaseUrl("bridge")}/v1/onramp/prepare`;
+
+  const apiRequestBody: OnrampApiRequestBody = {
+    onramp,
+    chainId: Number(chainId),
+    tokenAddress,
+    receiver,
+  };
+
+  if (amount !== undefined) {
+    apiRequestBody.amount = amount.toString();
+  }
+  if (purchaseData !== undefined) {
+    apiRequestBody.purchaseData = purchaseData;
+  }
+  if (sender !== undefined) {
+    apiRequestBody.sender = sender;
+  }
+  if (onrampTokenAddress !== undefined) {
+    apiRequestBody.onrampTokenAddress = onrampTokenAddress;
+  }
+  if (onrampChainId !== undefined) {
+    apiRequestBody.onrampChainId = Number(onrampChainId);
+  }
+  if (currency !== undefined) {
+    apiRequestBody.currency = currency;
+  }
+  if (maxSteps !== undefined) {
+    apiRequestBody.maxSteps = maxSteps;
+  }
+  if (excludeChainIds !== undefined) {
+    apiRequestBody.excludeChainIds = Array.isArray(excludeChainIds)
+      ? excludeChainIds.join(",")
+      : excludeChainIds;
+  }
+
+  const response = await clientFetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: stringify(apiRequestBody),
+  });
+
+  if (!response.ok) {
+    const errorJson = await response.json();
+    throw new Error(
+      `${errorJson.code || response.status} | ${errorJson.message || response.statusText} - ${errorJson.correlationId || "N/A"}`,
+    );
+  }
+
+  const { data }: { data: OnrampPrepareQuoteResponseData } =
+    await response.json();
+
+  // Transform amounts from string to bigint where appropriate
+  const transformedSteps = data.steps.map((step) => ({
+    ...step,
+    originAmount: BigInt(step.originAmount),
+    destinationAmount: BigInt(step.destinationAmount),
+    transactions: step.transactions.map((tx) => ({
+      ...tx,
+      value: tx.value ? BigInt(tx.value) : undefined,
+    })),
+  }));
+
+  const intentFromResponse = {
+    ...data.intent,
+    amount: data.intent.amount ? data.intent.amount : undefined,
+  };
+
+  return {
+    ...data,
+    destinationAmount: BigInt(data.destinationAmount),
+    steps: transformedSteps,
+    intent: intentFromResponse,
+  };
+}
+
+export declare namespace prepare {
+  export type Options = {
+    client: ThirdwebClient;
+    onramp: "stripe" | "coinbase" | "transak";
+    chainId: number;
+    tokenAddress: ox__Address.Address;
+    receiver: ox__Address.Address;
+    amount?: bigint;
+    purchaseData?: unknown;
+    sender?: ox__Address.Address;
+    onrampTokenAddress?: ox__Address.Address;
+    onrampChainId?: number;
+    currency?: string;
+    maxSteps?: number;
+    excludeChainIds?: string | string[];
+  };
+
+  export type Result = OnrampPrepareQuoteResponseData;
+}

package/src/bridge/OnrampStatus.ts

@@ -0,0 +1,133 @@
+import type { Hex as ox__Hex } from "ox";
+import type { ThirdwebClient } from "../client/client.js";
+import { getThirdwebBaseUrl } from "../utils/domains.js";
+import { getClientFetch } from "../utils/fetch.js";
+
+/**
+ * Retrieves the status of an Onramp session created via {@link Bridge.Onramp.prepare}. The
+ * status will include any on-chain transactions that have occurred as a result of the onramp
+ * as well as any arbitrary `purchaseData` that was supplied when the onramp was
+ * prepared.
+ *
+ * @example
+ * ```typescript
+ * import { Bridge } from "thirdweb";
+ *
+ * const onrampStatus = await Bridge.Onramp.status({
+ *   id: "022218cc-96af-4291-b90c-dadcb47571ec",
+ *   client: thirdwebClient,
+ * });
+ *
+ * // Possible results:
+ * // {
+ * //   status: "CREATED",
+ * //   transactions: [],
+ * //   purchaseData: {
+ * //     orderId: "abc-123",
+ * //   },
+ * // }
+ * //
+ * // or
+ * // {
+ * //   status: "PENDING",
+ * //   transactions: [],
+ * //   purchaseData: {
+ * //     orderId: "abc-123",
+ * //   },
+ * // }
+ * //
+ * // or
+ * // {
+ * //   status: "COMPLETED",
+ * //   transactions: [
+ * //     {
+ * //       chainId: 1,
+ * //       transactionHash:
+ * //         "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+ * //     },
+ * //   ],
+ * //   purchaseData: {
+ * //     orderId: "abc-123",
+ * //   },
+ * // }
+ * ```
+ *
+ * @param options - The options for fetching the onramp status.
+ * @param options.id - The UUID returned from {@link Bridge.Onramp.prepare}.
+ * @param options.client - Your thirdweb client instance.
+ *
+ * @returns A promise that resolves to the status of the onramp session.
+ *
+ * @throws Will throw an error if there is an issue fetching the status.
+ * @bridge Onramp
+ * @beta
+ */
+export async function status(options: status.Options): Promise<status.Result> {
+  const { id, client } = options;
+
+  const clientFetch = getClientFetch(client);
+  const url = new URL(`${getThirdwebBaseUrl("bridge")}/v1/onramp/status`);
+  url.searchParams.set("id", id);
+
+  const response = await clientFetch(url.toString());
+  if (!response.ok) {
+    const errorJson = await response.json();
+    throw new Error(
+      `${errorJson.code || response.status} | ${errorJson.message || response.statusText} - ${errorJson.correlationId || "N/A"}`,
+    );
+  }
+
+  const { data }: { data: status.Result } = await response.json();
+  return data;
+}
+
+export declare namespace status {
+  /**
+   * Input parameters for {@link Bridge.Onramp.status}.
+   */
+  export type Options = {
+    /**
+     * The Onramp session ID returned by {@link Bridge.Onramp.prepare}.
+     */
+    id: string;
+    /** Your {@link ThirdwebClient} instance. */
+    client: ThirdwebClient;
+  };
+
+  /**
+   * The result returned from {@link Bridge.Onramp.status}.
+   */
+  export type Result =
+    | {
+        status: "COMPLETED";
+        transactions: Array<{
+          chainId: number;
+          transactionHash: ox__Hex.Hex;
+        }>;
+        purchaseData?: unknown;
+      }
+    | {
+        status: "PENDING";
+        transactions: Array<{
+          chainId: number;
+          transactionHash: ox__Hex.Hex;
+        }>;
+        purchaseData?: unknown;
+      }
+    | {
+        status: "CREATED";
+        transactions: Array<{
+          chainId: number;
+          transactionHash: ox__Hex.Hex;
+        }>;
+        purchaseData?: unknown;
+      }
+    | {
+        status: "FAILED";
+        transactions: Array<{
+          chainId: number;
+          transactionHash: ox__Hex.Hex;
+        }>;
+        purchaseData?: unknown;
+      };
+}

package/src/bridge/Routes.ts

@@ -1,7 +1,7 @@
 import type { Address as ox__Address, Hex as ox__Hex } from "ox";
 import type { ThirdwebClient } from "../client/client.js";
+import { getThirdwebBaseUrl } from "../utils/domains.js";
 import { getClientFetch } from "../utils/fetch.js";
-import { UNIVERSAL_BRIDGE_URL } from "./constants.js";
 import type { Route } from "./types/Route.js";
 
 /**
@@ -133,7 +133,7 @@ export async function routes(options: routes.Options): Promise<routes.Result> {
   } = options;
 
   const clientFetch = getClientFetch(client);
-  const url = new URL(`${UNIVERSAL_BRIDGE_URL}/routes`);
+  const url = new URL(`${getThirdwebBaseUrl("bridge")}/v1/routes`);
   if (originChainId) {
     url.searchParams.set("originChainId", originChainId.toString());
   }

package/src/bridge/Sell.ts

@@ -1,9 +1,9 @@
 import type { Address as ox__Address } from "ox";
 import { defineChain } from "../chains/utils.js";
 import type { ThirdwebClient } from "../client/client.js";
+import { getThirdwebBaseUrl } from "../utils/domains.js";
 import { getClientFetch } from "../utils/fetch.js";
 import { stringify } from "../utils/json.js";
-import { UNIVERSAL_BRIDGE_URL } from "./constants.js";
 import type { PreparedQuote, Quote } from "./types/Quote.js";
 
 /**
@@ -112,12 +112,13 @@ export async function quote(options: quote.Options): Promise<quote.Result> {
   } = options;
 
   const clientFetch = getClientFetch(client);
-  const url = new URL(`${UNIVERSAL_BRIDGE_URL}/sell/quote`);
+  const url = new URL(`${getThirdwebBaseUrl("bridge")}/v1/sell/quote`);
   url.searchParams.set("originChainId", originChainId.toString());
   url.searchParams.set("originTokenAddress", originTokenAddress);
   url.searchParams.set("destinationChainId", destinationChainId.toString());
   url.searchParams.set("destinationTokenAddress", destinationTokenAddress);
   url.searchParams.set("sellAmountWei", amount.toString());
+  url.searchParams.set("amount", amount.toString());
   if (typeof maxSteps !== "undefined") {
     url.searchParams.set("maxSteps", maxSteps.toString());
   }
@@ -190,7 +191,7 @@ export declare namespace quote {
  * This will return a quote that might look like:
  * ```typescript
  * {
- *   originAmount: 1000000000000000000n,
+ *   originAmount: 2000000000n,
  *   destinationAmount:  9980000000000000000n,
  *   blockNumber: 22026509n,
  *   timestamp: 1741730936680,
@@ -199,11 +200,11 @@ export declare namespace quote {
  *     {
  *       originToken: {
  *         chainId: 1,
- *         address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
- *         symbol: "ETH",
- *         name: "Ethereum",
- *         decimals: 18,
- *         priceUsd: 2000,
+ *         address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+ *         symbol: "USDC",
+ *         name: "USDC",
+ *         decimals: 6,
+ *         priceUsd: 1,
  *         iconUri: "https://..."
  *       },
  *       destinationToken: {
@@ -215,7 +216,7 @@ export declare namespace quote {
  *         priceUsd: 2000,
  *         iconUri: "https://..."
  *       },
- *       originAmount: 1000000000000000000n,
+ *       originAmount: 2000000000n,
  *       destinationAmount:  9980000000000000000n,
  *       estimatedExecutionTimeMs: 1000
  *     }
@@ -241,16 +242,16 @@ export declare namespace quote {
  *   expiration: 1741730936680,
  *   intent: {
  *     originChainId: 1,
- *     originTokenAddress: NATIVE_TOKEN_ADDRESS,
+ *     originTokenAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
  *     destinationChainId: 10,
- *     destinationTokenAddress: NATIVE_TOKEN_ADDRESS,
- *     amount: 1000000000000000000n
+ *     destinationTokenAddress: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+ *     amount: 2000000000n
  *   }
  * }
  * ```
  *
  * ## Sending the transactions
- * The `transactions` array is a series of [ox](https://oxlib.sh) EIP-1559 transactions that must be executed one after the other in order to fulfill the complete route. There are a few things to keep in mind when executing these transactions:
+ * The `transactions` array is a series of transactions ready to be executed (with `sendTransaction`) must be executed one after the other in order to fulfill the complete route. There are a few things to keep in mind when executing these transactions:
  *  - Approvals will have the `approval` action specified. You can perform approvals with `sendAndConfirmTransaction`, then proceed to the next transaction.
  *  - All transactions are assumed to be executed by the `sender` address, regardless of which chain they are on. The final transaction will use the `receiver` as the recipient address.
  *  - If an `expiration` timestamp is provided, all transactions must be executed before that time to guarantee successful execution at the specified price.
@@ -325,7 +326,7 @@ export async function prepare(
   } = options;
 
   const clientFetch = getClientFetch(client);
-  const url = new URL(`${UNIVERSAL_BRIDGE_URL}/sell/prepare`);
+  const url = new URL(`${getThirdwebBaseUrl("bridge")}/v1/sell/prepare`);
 
   const response = await clientFetch(url.toString(), {
     method: "POST",
@@ -334,6 +335,7 @@ export async function prepare(
     },
     body: stringify({
       sellAmountWei: amount.toString(),
+      amount: amount.toString(),
       originChainId: originChainId.toString(),
       originTokenAddress,
       destinationChainId: destinationChainId.toString(),
@@ -374,6 +376,8 @@ export async function prepare(
       destinationChainId,
       destinationTokenAddress,
       amount,
+      sender,
+      receiver,
       purchaseData,
     },
   };
@@ -400,6 +404,8 @@ export declare namespace prepare {
       destinationChainId: number;
       destinationTokenAddress: ox__Address.Address;
       amount: bigint;
+      sender: ox__Address.Address;
+      receiver: ox__Address.Address;
       purchaseData?: unknown;
     };
   };

package/src/bridge/Status.ts

@@ -1,8 +1,8 @@
 import type { Hex as ox__Hex } from "ox";
 import type { Chain } from "../chains/types.js";
 import type { ThirdwebClient } from "../client/client.js";
+import { getThirdwebBaseUrl } from "../utils/domains.js";
 import { getClientFetch } from "../utils/fetch.js";
-import { UNIVERSAL_BRIDGE_URL } from "./constants.js";
 import type { Status } from "./types/Status.js";
 
 /**
@@ -108,7 +108,7 @@ export async function status(options: status.Options): Promise<status.Result> {
   const chainId = "chainId" in options ? options.chainId : options.chain.id;
 
   const clientFetch = getClientFetch(client);
-  const url = new URL(`${UNIVERSAL_BRIDGE_URL}/status`);
+  const url = new URL(`${getThirdwebBaseUrl("bridge")}/v1/status`);
   url.searchParams.set("transactionHash", transactionHash);
   url.searchParams.set("chainId", chainId.toString());
 
@@ -124,6 +124,7 @@ export async function status(options: status.Options): Promise<status.Result> {
   if (data.status === "FAILED") {
     return {
       status: "FAILED",
+      paymentId: data.paymentId,
       transactions: data.transactions,
     };
   }
@@ -137,12 +138,19 @@ export async function status(options: status.Options): Promise<status.Result> {
       originTokenAddress: data.originTokenAddress,
       destinationTokenAddress: data.destinationTokenAddress,
       transactions: data.transactions,
+      originToken: data.originToken,
+      destinationToken: data.destinationToken,
+      sender: data.sender,
+      receiver: data.receiver,
+      paymentId: data.paymentId,
+      purchaseData: data.purchaseData,
     };
   }
 
   if (data.status === "NOT_FOUND") {
     return {
       status: "NOT_FOUND",
+      paymentId: data.paymentId,
       transactions: [],
     };
   }
@@ -156,6 +164,11 @@ export async function status(options: status.Options): Promise<status.Result> {
     originTokenAddress: data.originTokenAddress,
     destinationTokenAddress: data.destinationTokenAddress,
     transactions: data.transactions,
+    originToken: data.originToken,
+    destinationToken: data.destinationToken,
+    sender: data.sender,
+    receiver: data.receiver,
+    paymentId: data.paymentId,
     purchaseData: data.purchaseData,
   };
 }

package/src/bridge/Transfer.test.ts

@@ -0,0 +1,76 @@
+import { toWei } from "src/utils/units.js";
+import { describe, expect, it } from "vitest";
+import { TEST_CLIENT } from "~test/test-clients.js";
+import * as Transfer from "./Transfer.js";
+
+describe.runIf(process.env.TW_SECRET_KEY)("Bridge.Transfer.prepare", () => {
+  it("should get a valid prepared quote", async () => {
+    const quote = await Transfer.prepare({
+      chainId: 1,
+      tokenAddress: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+      amount: toWei("0.01"),
+      sender: "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709",
+      receiver: "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709",
+      client: TEST_CLIENT,
+      purchaseData: {
+        reference: "test-transfer",
+      },
+    });
+
+    expect(quote).toBeDefined();
+    expect(quote.intent.amount).toEqual(toWei("0.01"));
+    for (const step of quote.steps) {
+      expect(step.transactions.length).toBeGreaterThan(0);
+    }
+    expect(quote.intent).toBeDefined();
+  });
+
+  it("should surface any errors", async () => {
+    await expect(
+      Transfer.prepare({
+        chainId: 444, // Invalid chain ID
+        tokenAddress: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+        amount: toWei("1000000000"),
+        sender: "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709",
+        receiver: "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709",
+        client: TEST_CLIENT,
+      }),
+    ).rejects.toThrowError();
+  });
+
+  it("should support the feePayer option", async () => {
+    const senderQuote = await Transfer.prepare({
+      chainId: 1,
+      tokenAddress: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+      amount: toWei("0.01"),
+      sender: "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709",
+      receiver: "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709",
+      feePayer: "sender",
+      client: TEST_CLIENT,
+    });
+
+    expect(senderQuote).toBeDefined();
+    expect(senderQuote.intent.feePayer).toBe("sender");
+
+    const receiverQuote = await Transfer.prepare({
+      chainId: 1,
+      tokenAddress: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+      amount: toWei("0.01"),
+      sender: "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709",
+      receiver: "0x2a4f24F935Eb178e3e7BA9B53A5Ee6d8407C0709",
+      feePayer: "receiver",
+      client: TEST_CLIENT,
+    });
+
+    expect(receiverQuote).toBeDefined();
+    expect(receiverQuote.intent.feePayer).toBe("receiver");
+
+    // When receiver pays fees, the destination amount should be less than the requested amount
+    expect(receiverQuote.destinationAmount).toBeLessThan(toWei("0.01"));
+
+    // When sender pays fees, the origin amount should be more than the requested amount
+    // and the destination amount should equal the requested amount
+    expect(senderQuote.originAmount).toBeGreaterThan(toWei("0.01"));
+    expect(senderQuote.destinationAmount).toEqual(toWei("0.01"));
+  });
+});