update

Author: kien-ngo

packages/thirdweb/src/exports/utils.ts

@@ -1,7 +1,7 @@
 // bytecode
 export { detectMethod } from "../utils/bytecode/detectExtension.js";
 export { extractIPFSUri } from "../utils/bytecode/extractIPFS.js";
-export { extractMinimalProxyImplementationAddress } from "../utils/bytecode/extractMnimalProxyImplementationAddress.js";
+export { extractMinimalProxyImplementationAddress } from "../utils/bytecode/extractMinimalProxyImplementationAddress.js";
 export { isContractDeployed } from "../utils/bytecode/is-contract-deployed.js";
 export { ensureBytecodePrefix } from "../utils/bytecode/prefix.js";
 export { resolveImplementation } from "../utils/bytecode/resolveImplementation.js";

packages/thirdweb/src/react/web/ui/ConnectWallet/screens/Buy/fiat/currencies.test.tsx

@@ -0,0 +1,52 @@
+import { describe, expect, it } from "vitest";
+import { CADIcon } from "../../../icons/currencies/CADIcon.js";
+import { EURIcon } from "../../../icons/currencies/EURIcon.js";
+import { GBPIcon } from "../../../icons/currencies/GBPIcon.js";
+import { JPYIcon } from "../../../icons/currencies/JPYIcon.js";
+import { USDIcon } from "../../../icons/currencies/USDIcon.js";
+import { currencies, getCurrencyMeta, usdCurrency } from "./currencies.js";
+
+describe("Currency Utilities", () => {
+  it("should have correct number of currencies", () => {
+    expect(currencies.length).toBe(5);
+  });
+
+  it("should have USD as the first currency", () => {
+    expect(currencies[0]).toEqual(usdCurrency);
+  });
+
+  it("should have correct properties for each currency", () => {
+    for (const currency of currencies) {
+      expect(currency).toHaveProperty("shorthand");
+      expect(currency).toHaveProperty("name");
+      expect(currency).toHaveProperty("icon");
+    }
+  });
+
+  describe("getCurrencyMeta function", () => {
+    it("should return correct currency meta for valid shorthand", () => {
+      const cadMeta = getCurrencyMeta("CAD");
+      expect(cadMeta.shorthand).toBe("CAD");
+      expect(cadMeta.name).toBe("Canadian Dollar");
+      expect(cadMeta.icon).toBe(CADIcon);
+    });
+
+    it("should be case-insensitive", () => {
+      const eurMeta = getCurrencyMeta("eur");
+      expect(eurMeta.shorthand).toBe("EUR");
+      expect(eurMeta.name).toBe("Euro");
+      expect(eurMeta.icon).toBe(EURIcon);
+    });
+
+    it("should return unknown currency for invalid shorthand", () => {
+      const unknownMeta = getCurrencyMeta("XYZ");
+      expect(unknownMeta.shorthand).toBe("XYZ");
+      expect(unknownMeta.name).toBe("XYZ");
+      expect(unknownMeta.icon).not.toBe(USDIcon);
+      expect(unknownMeta.icon).not.toBe(CADIcon);
+      expect(unknownMeta.icon).not.toBe(GBPIcon);
+      expect(unknownMeta.icon).not.toBe(EURIcon);
+      expect(unknownMeta.icon).not.toBe(JPYIcon);
+    });
+  });
+});

packages/thirdweb/src/react/web/ui/ConnectWallet/screens/Buy/pay-transactions/statusMeta.test.ts

@@ -0,0 +1,174 @@
+import { describe, expect, it } from "vitest";
+import type { BuyWithCryptoStatus } from "../../../../../../../pay/buyWithCrypto/getStatus.js";
+import type { BuyWithFiatStatus } from "../../../../../../../pay/buyWithFiat/getStatus.js";
+import {
+  getBuyWithCryptoStatusMeta,
+  getBuyWithFiatStatusMeta,
+} from "./statusMeta.js";
+
+describe("getBuyWithCryptoStatusMeta", () => {
+  it('returns "Unknown" for NOT_FOUND status', () => {
+    const result = getBuyWithCryptoStatusMeta({
+      status: "NOT_FOUND",
+    } as BuyWithCryptoStatus);
+    expect(result).toEqual({
+      status: "Unknown",
+      color: "secondaryText",
+    });
+  });
+
+  it('returns "Bridging" for WAITING_BRIDGE subStatus', () => {
+    const result = getBuyWithCryptoStatusMeta({
+      status: "PENDING",
+      subStatus: "WAITING_BRIDGE",
+    } as BuyWithCryptoStatus);
+    expect(result).toEqual({
+      status: "Bridging",
+      color: "accentText",
+      loading: true,
+    });
+  });
+
+  it('returns "Incomplete" for PARTIAL_SUCCESS subStatus', () => {
+    const result = getBuyWithCryptoStatusMeta({
+      status: "COMPLETED",
+      subStatus: "PARTIAL_SUCCESS",
+    } as BuyWithCryptoStatus);
+    expect(result).toEqual({
+      status: "Incomplete",
+      color: "secondaryText",
+    });
+  });
+
+  it('returns "Pending" for PENDING status', () => {
+    const result = getBuyWithCryptoStatusMeta({
+      status: "PENDING",
+    } as BuyWithCryptoStatus);
+    expect(result).toEqual({
+      status: "Pending",
+      color: "accentText",
+      loading: true,
+    });
+  });
+
+  it('returns "Failed" for FAILED status', () => {
+    const result = getBuyWithCryptoStatusMeta({
+      status: "FAILED",
+    } as BuyWithCryptoStatus);
+    expect(result).toEqual({
+      status: "Failed",
+      color: "danger",
+    });
+  });
+
+  it('returns "Completed" for COMPLETED status', () => {
+    const result = getBuyWithCryptoStatusMeta({
+      status: "COMPLETED",
+    } as BuyWithCryptoStatus);
+    expect(result).toEqual({
+      status: "Completed",
+      color: "success",
+    });
+  });
+
+  it('returns "Unknown" for unhandled status', () => {
+    const result = getBuyWithCryptoStatusMeta({
+      // @ts-ignore Test purpose
+      status: "Unknown",
+    });
+    expect(result).toEqual({
+      status: "Unknown",
+      color: "secondaryText",
+    });
+  });
+});
+
+describe("getBuyWithFiatStatusMeta", () => {
+  it('returns "Incomplete" for CRYPTO_SWAP_FALLBACK status', () => {
+    const result = getBuyWithFiatStatusMeta({
+      status: "CRYPTO_SWAP_FALLBACK",
+    } as BuyWithFiatStatus);
+    expect(result).toEqual({
+      status: "Incomplete",
+      color: "danger",
+      step: 2,
+      progressStatus: "partialSuccess",
+    });
+  });
+
+  it('returns "Pending" for CRYPTO_SWAP_IN_PROGRESS status', () => {
+    const result = getBuyWithFiatStatusMeta({
+      status: "CRYPTO_SWAP_IN_PROGRESS",
+    } as BuyWithFiatStatus);
+    expect(result).toEqual({
+      status: "Pending",
+      color: "accentText",
+      loading: true,
+      step: 2,
+      progressStatus: "pending",
+    });
+  });
+
+  it('returns "Pending" for PENDING_ON_RAMP_TRANSFER status', () => {
+    const result = getBuyWithFiatStatusMeta({
+      status: "PENDING_ON_RAMP_TRANSFER",
+    } as BuyWithFiatStatus);
+    expect(result).toEqual({
+      status: "Pending",
+      color: "accentText",
+      loading: true,
+      step: 1,
+      progressStatus: "pending",
+    });
+  });
+
+  it('returns "Completed" for ON_RAMP_TRANSFER_COMPLETED status', () => {
+    const result = getBuyWithFiatStatusMeta({
+      status: "ON_RAMP_TRANSFER_COMPLETED",
+    } as BuyWithFiatStatus);
+    expect(result).toEqual({
+      status: "Completed",
+      color: "success",
+      loading: true,
+      step: 1,
+      progressStatus: "completed",
+    });
+  });
+
+  it('returns "Action Required" for CRYPTO_SWAP_REQUIRED status', () => {
+    const result = getBuyWithFiatStatusMeta({
+      status: "CRYPTO_SWAP_REQUIRED",
+    } as BuyWithFiatStatus);
+    expect(result).toEqual({
+      status: "Action Required",
+      color: "accentText",
+      step: 2,
+      progressStatus: "actionRequired",
+    });
+  });
+
+  it('returns "Failed" for PAYMENT_FAILED status', () => {
+    const result = getBuyWithFiatStatusMeta({
+      status: "PAYMENT_FAILED",
+    } as BuyWithFiatStatus);
+    expect(result).toEqual({
+      status: "Failed",
+      color: "danger",
+      step: 1,
+      progressStatus: "failed",
+    });
+  });
+
+  it('returns "Unknown" for unhandled status', () => {
+    const result = getBuyWithFiatStatusMeta({
+      // @ts-ignore
+      status: "UNKNOWN_STATUS",
+    });
+    expect(result).toEqual({
+      status: "Unknown",
+      color: "secondaryText",
+      step: 1,
+      progressStatus: "unknown",
+    });
+  });
+});

packages/thirdweb/src/react/web/ui/ConnectWallet/screens/Buy/swap/formatSeconds.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { formatSeconds } from "./formatSeconds.js";
+
+describe("formatSeconds", () => {
+  it("formats seconds to hours and minutes when over 3600 seconds", () => {
+    expect(formatSeconds(3601)).toBe("1 Hours 0 Minutes");
+    expect(formatSeconds(7200)).toBe("2 Hours 0 Minutes");
+    expect(formatSeconds(5400)).toBe("1 Hours 30 Minutes");
+    expect(formatSeconds(12345)).toBe("3 Hours 25 Minutes");
+  });
+
+  it("formats seconds to minutes when between 61 and 3600 seconds", () => {
+    expect(formatSeconds(61)).toBe("2 Minutes");
+    expect(formatSeconds(120)).toBe("2 Minutes");
+    expect(formatSeconds(3599)).toBe("60 Minutes");
+    expect(formatSeconds(1800)).toBe("30 Minutes");
+  });
+
+  it('formats seconds to "Xs" when 60 seconds or less', () => {
+    expect(formatSeconds(60)).toBe("60s");
+    expect(formatSeconds(59)).toBe("59s");
+    expect(formatSeconds(1)).toBe("1s");
+    expect(formatSeconds(0)).toBe("0s");
+  });
+
+  it("handles decimal inputs by rounding down for hours/minutes and up for minutes only", () => {
+    expect(formatSeconds(3661.5)).toBe("1 Hours 1 Minutes");
+    expect(formatSeconds(119.9)).toBe("2 Minutes");
+  });
+});

packages/thirdweb/src/react/web/ui/ConnectWallet/screens/Buy/utils.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import { getBuyTokenAmountFontSize } from "./utils.js";
+
+describe("getBuyTokenAmountFontSize", () => {
+  it("returns 26px for strings longer than 10 characters", () => {
+    expect(getBuyTokenAmountFontSize("12345678901")).toBe("26px");
+    expect(getBuyTokenAmountFontSize("1234567890123")).toBe("26px");
+  });
+
+  it("returns 34px for strings longer than 6 characters but not more than 10", () => {
+    expect(getBuyTokenAmountFontSize("1234567")).toBe("34px");
+    expect(getBuyTokenAmountFontSize("1234567890")).toBe("34px");
+  });
+
+  it("returns 50px for strings 6 characters or shorter", () => {
+    expect(getBuyTokenAmountFontSize("123456")).toBe("50px");
+    expect(getBuyTokenAmountFontSize("12345")).toBe("50px");
+    expect(getBuyTokenAmountFontSize("")).toBe("50px");
+  });
+});

packages/thirdweb/src/utils/bigint.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { max, min, toBigInt } from "./bigint.js";
+import { max, min, replaceBigInts, toBigInt } from "./bigint.js";
 
 describe("min", () => {
   it("should return the smaller value when a is smaller than b", () => {
@@ -79,4 +79,94 @@ describe("toBigInt", () => {
       `Expected value to be an integer to convert to a bigint, got ${value} of type number`,
     );
   });
+
+  it("should convert a Uint8Array to a BigInt", () => {
+    const uint8Array = new Uint8Array([1, 2, 3, 4]);
+    const result = toBigInt(uint8Array);
+    expect(result).toBe(BigInt("0x01020304"));
+  });
+
+  it("should handle a Uint8Array with leading zeros", () => {
+    const uint8Array = new Uint8Array([0, 0, 1, 2]);
+    const result = toBigInt(uint8Array);
+    expect(result).toBe(BigInt("0x00000102"));
+  });
+
+  it("should handle a large Uint8Array", () => {
+    const uint8Array = new Uint8Array([255, 255, 255, 255]);
+    const result = toBigInt(uint8Array);
+    expect(result).toBe(BigInt("0xffffffff"));
+  });
+
+  describe("replaceBigInts", () => {
+    it("should replace a single bigint value", () => {
+      const input = BigInt(123);
+      const result = replaceBigInts(input, (x) => x.toString());
+      expect(result).toBe("123");
+    });
+
+    it("should handle arrays containing bigints", () => {
+      const input = [BigInt(1), BigInt(2), BigInt(3)];
+      const result = replaceBigInts(input, (x) => x.toString());
+      expect(result).toEqual(["1", "2", "3"]);
+    });
+
+    it("should handle nested arrays with bigints", () => {
+      const input = [BigInt(1), [BigInt(2), BigInt(3)]];
+      const result = replaceBigInts(input, (x) => x.toString());
+      expect(result).toEqual(["1", ["2", "3"]]);
+    });
+
+    it("should handle objects containing bigints", () => {
+      const input = { a: BigInt(1), b: BigInt(2) };
+      const result = replaceBigInts(input, (x) => x.toString());
+      expect(result).toEqual({ a: "1", b: "2" });
+    });
+
+    it("should handle nested objects with bigints", () => {
+      const input = { a: BigInt(1), b: { c: BigInt(2), d: BigInt(3) } };
+      const result = replaceBigInts(input, (x) => x.toString());
+      expect(result).toEqual({ a: "1", b: { c: "2", d: "3" } });
+    });
+
+    it("should handle mixed arrays and objects", () => {
+      const input = {
+        a: [BigInt(1), { b: BigInt(2), c: [BigInt(3)] }],
+      };
+      const result = replaceBigInts(input, (x) => x.toString());
+      expect(result).toEqual({ a: ["1", { b: "2", c: ["3"] }] });
+    });
+
+    it("should handle empty arrays and objects", () => {
+      expect(replaceBigInts([], (x) => x.toString())).toEqual([]);
+      expect(replaceBigInts({}, (x) => x.toString())).toEqual({});
+    });
+
+    it("should leave other types untouched", () => {
+      const input = {
+        a: "string",
+        b: 42,
+        c: null,
+        d: undefined,
+        e: true,
+        f: [1, "test"],
+      };
+      const result = replaceBigInts(input, (x) => x.toString());
+      expect(result).toEqual(input);
+    });
+
+    it("should handle complex deeply nested structures", () => {
+      const input = {
+        a: BigInt(1),
+        b: [BigInt(2), { c: [BigInt(3), { d: BigInt(4) }] }],
+        e: { f: { g: BigInt(5) } },
+      };
+      const result = replaceBigInts(input, (x) => x.toString());
+      expect(result).toEqual({
+        a: "1",
+        b: ["2", { c: ["3", { d: "4" }] }],
+        e: { f: { g: "5" } },
+      });
+    });
+  });
 });