thirdweb 5.115.3 → 5.115.4

package/dist/types/utils/base64/base64.d.ts

@@ -1,5 +1,5 @@
-type Base64Prefix = "data:application/json;base64";
-type Base64String = `${Base64Prefix},${string}`;
+declare const Base64Prefix: "data:application/json;base64";
+type Base64String = `${typeof Base64Prefix},${string}`;
 /**
  * Checks if a given string is a base64 encoded JSON string.
  * @param input - The string to be checked.

package/dist/types/utils/base64/base64.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../../../../src/utils/base64/base64.ts"],"names":[],"mappings":"AAEA,KAAK,YAAY,GAAG,8BAA8B,CAAC;AACnD,KAAK,YAAY,GAAG,GAAG,YAAY,IAAI,MAAM,EAAE,CAAC;AAEhD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,YAAY,CAKjE;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,UAGpD"}
+{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../../../../src/utils/base64/base64.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,YAAY,EAAG,8BAAuC,CAAC;AAC7D,KAAK,YAAY,GAAG,GAAG,OAAO,YAAY,IAAI,MAAM,EAAE,CAAC;AAEvD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,YAAY,CAKjE;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,UAIpD"}

package/dist/types/utils/contract/fetchContractMetadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetchContractMetadata.d.ts","sourceRoot":"","sources":["../../../../src/utils/contract/fetchContractMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAG7D;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,cAAc,CAAC;IACvB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,GAAG,SAAS,CAAC,CAqBjD"}
+{"version":3,"file":"fetchContractMetadata.d.ts","sourceRoot":"","sources":["../../../../src/utils/contract/fetchContractMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAI7D;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,cAAc,CAAC;IACvB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,GAAG,SAAS,CAAC,CAiCjD"}

package/dist/types/utils/nft/fetchTokenMetadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetchTokenMetadata.d.ts","sourceRoot":"","sources":["../../../../src/utils/nft/fetchTokenMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAG7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC,MAAM,EAAE,cAAc,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,WAAW,CAAC,CAuDtB"}
+{"version":3,"file":"fetchTokenMetadata.d.ts","sourceRoot":"","sources":["../../../../src/utils/nft/fetchTokenMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAI7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC,MAAM,EAAE,cAAc,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,WAAW,CAAC,CAmEtB"}

package/dist/types/utils/utf8/utf8.d.ts

@@ -0,0 +1,26 @@
+declare const UTF8Prefix: "data:application/json;utf-8";
+type UTF8String = `${typeof UTF8Prefix},${string}`;
+/**
+ * Checks if a given string is a UTF-8 encoded JSON string.
+ * @param input - The string to be checked.
+ * @returns True if the input string starts with "data:application/json;utf-8", false otherwise.
+ * @example
+ * ```ts
+ * isUTF8JSONString("data:application/json;utf-8,{ \"test\": \"utf8\" }")
+ * // true
+ * ```
+ */
+export declare function isUTF8JSONString(input: string): input is UTF8String;
+/**
+ * Parses a UTF-8 string and returns the decoded string.
+ * @param input - The UTF-8 string to parse.
+ * @returns The decoded string.
+ * @example
+ * ```ts
+ * parseUTF8String("data:application/json;utf-8,{ \"test\": \"utf8\" }")
+ * // '{"test":"utf8"}'
+ * ```
+ */
+export declare function parseUTF8String(input: UTF8String): string;
+export {};
+//# sourceMappingURL=utf8.d.ts.map

package/dist/types/utils/utf8/utf8.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utf8.d.ts","sourceRoot":"","sources":["../../../../src/utils/utf8/utf8.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,UAAU,EAAG,6BAAsC,CAAC;AAC1D,KAAK,UAAU,GAAG,GAAG,OAAO,UAAU,IAAI,MAAM,EAAE,CAAC;AAEnD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,UAAU,CAKnE;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,UAShD"}

package/dist/types/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "5.115.3";
+export declare const version = "5.115.4";
 //# sourceMappingURL=version.d.ts.map

package/dist/types/wallets/utils/getWalletBalance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getWalletBalance.d.ts","sourceRoot":"","sources":["../../../../src/wallets/utils/getWalletBalance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAMnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAG7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAMlF,MAAM,MAAM,uBAAuB,GAAG;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,cAAc,CAAC;IACvB,KAAK,EAAE,KAAK,CAAC;IACb;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,gBAAgB,CAAC;AAEtD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,gBAAgB,CAAC,CAoC3B"}
+{"version":3,"file":"getWalletBalance.d.ts","sourceRoot":"","sources":["../../../../src/wallets/utils/getWalletBalance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAMnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAG7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAMlF,MAAM,MAAM,uBAAuB,GAAG;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,cAAc,CAAC;IACvB,KAAK,EAAE,KAAK,CAAC;IACb;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,gBAAgB,CAAC;AAEtD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,gBAAgB,CAAC,CA4C3B"}

package/package.json

@@ -399,7 +399,7 @@
     }
   },
   "typings": "./dist/types/exports/thirdweb.d.ts",
-  "version": "5.115.3",
+  "version": "5.115.4",
   "scripts": {
     "bench": "vitest -c ./test/vitest.config.ts bench",
     "bench:compare": "bun run ./benchmarks/run.ts",

package/src/utils/base64/base64.ts

@@ -1,7 +1,7 @@
 import { base64ToString } from "../uint8-array.js";
 
-type Base64Prefix = "data:application/json;base64";
-type Base64String = `${Base64Prefix},${string}`;
+const Base64Prefix = "data:application/json;base64" as const;
+type Base64String = `${typeof Base64Prefix},${string}`;
 
 /**
  * Checks if a given string is a base64 encoded JSON string.
@@ -14,7 +14,7 @@ type Base64String = `${Base64Prefix},${string}`;
  * ```
  */
 export function isBase64JSON(input: string): input is Base64String {
-  if (input.startsWith("data:application/json;base64")) {
+  if (input.toLowerCase().startsWith(Base64Prefix)) {
     return true;
   }
   return false;
@@ -31,6 +31,7 @@ export function isBase64JSON(input: string): input is Base64String {
  * ```
  */
 export function parseBase64String(input: Base64String) {
-  const [, base64] = input.split(",") as [Base64Prefix, string];
+  const commaIndex = input.indexOf(",");
+  const base64 = input.slice(commaIndex + 1);
   return base64ToString(base64);
 }

package/src/utils/contract/fetchContractMetadata.ts

@@ -1,5 +1,6 @@
 import type { ThirdwebClient } from "../../client/client.js";
 import { isBase64JSON, parseBase64String } from "../base64/base64.js";
+import { isUTF8JSONString, parseUTF8String } from "../utf8/utf8.js";
 
 /**
  * @internal
@@ -34,6 +35,18 @@ export async function fetchContractMetadata(
       return undefined;
     }
   }
+  if (isUTF8JSONString(uri)) {
+    try {
+      return JSON.parse(parseUTF8String(uri));
+    } catch (e) {
+      console.error(
+        "Failed to fetch utf8 encoded contract metadata",
+        { uri },
+        e,
+      );
+      return undefined;
+    }
+  }
 
   // in all other cases we will need the `download` function from storage
 

package/src/utils/nft/fetch-token-metadata.test.ts

@@ -34,4 +34,42 @@ describe("fetchTokenMetadata", () => {
     };
     await expect(fetchTokenMetadata(options)).rejects.toThrowError();
   });
+
+  it("should return a json object from a valid UTF-8 encoded json", async () => {
+    const validJson = { name: "NFT Name", description: "NFT Description" };
+    const validUtf8Json = `data:application/json;utf-8,${stringify(validJson)}`;
+
+    const options: FetchTokenMetadataOptions = {
+      client: TEST_CLIENT,
+      tokenId: 1n,
+      tokenUri: validUtf8Json,
+    };
+    const result = await fetchTokenMetadata(options);
+    expect(result).toEqual(validJson);
+  });
+
+  it("should return a json object from UTF-8 encoded json with unicode characters", async () => {
+    const validJson = { name: "🎉 NFT", emoji: "🚀", text: "Hello World" };
+    const validUtf8Json = `data:application/json;utf-8,${stringify(validJson)}`;
+
+    const options: FetchTokenMetadataOptions = {
+      client: TEST_CLIENT,
+      tokenId: 2n,
+      tokenUri: validUtf8Json,
+    };
+    const result = await fetchTokenMetadata(options);
+    expect(result).toEqual(validJson);
+  });
+
+  it("should throw an error for INVALID UTF-8 encoded json", async () => {
+    // Malformed JSON: { "foo": "bar" (missing closing brace)
+    const invalidUtf8Json = 'data:application/json;utf-8,{"foo": "bar"';
+
+    const options: FetchTokenMetadataOptions = {
+      client: TEST_CLIENT,
+      tokenId: 3n,
+      tokenUri: invalidUtf8Json,
+    };
+    await expect(fetchTokenMetadata(options)).rejects.toThrowError();
+  });
 });

package/src/utils/nft/fetchTokenMetadata.ts

@@ -1,6 +1,7 @@
 import type { ThirdwebClient } from "../../client/client.js";
 import { isBase64JSON, parseBase64String } from "../base64/base64.js";
 import { numberToHex } from "../encoding/hex.js";
+import { isUTF8JSONString, parseUTF8String } from "../utf8/utf8.js";
 import type { NFTMetadata } from "./parseNft.js";
 
 /**
@@ -37,6 +38,18 @@ export async function fetchTokenMetadata(
     }
   }
 
+  if (isUTF8JSONString(tokenUri)) {
+    try {
+      return JSON.parse(parseUTF8String(tokenUri));
+    } catch (e) {
+      console.error(
+        "Failed to fetch utf8 encoded NFT",
+        { tokenId, tokenUri },
+        e,
+      );
+      throw e;
+    }
+  }
   // in all other cases we will need the `download` function from storage
   const { download } = await import("../../storage/download.js");
 

package/src/utils/utf8/utf8.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from "vitest";
+import { isUTF8JSONString, parseUTF8String } from "./utf8.js";
+
+describe("isUTF8JSONString", () => {
+  it("should return true for valid UTF-8 JSON string", () => {
+    const input = 'data:application/json;utf-8,{"test":"value"}';
+    const result = isUTF8JSONString(input);
+    expect(result).toBe(true);
+  });
+
+  it("should return true for UTF-8 JSON string with special text", () => {
+    const input = 'data:application/json;utf-8,{"text":"Hello World!"}';
+    const result = isUTF8JSONString(input);
+    expect(result).toBe(true);
+  });
+
+  it("should return false for plain string without prefix", () => {
+    const input = "Hello world";
+    const result = isUTF8JSONString(input);
+    expect(result).toBe(false);
+  });
+
+  it("should return false for base64 JSON string", () => {
+    const input = "data:application/json;base64,eyJ0ZXN0IjoidmFsdWUifQ==";
+    const result = isUTF8JSONString(input);
+    expect(result).toBe(false);
+  });
+
+  it("should return false for different data type with utf-8", () => {
+    const input = "data:text/plain;utf-8,Hello world";
+    const result = isUTF8JSONString(input);
+    expect(result).toBe(false);
+  });
+
+  it("should return false for empty string", () => {
+    const input = "";
+    const result = isUTF8JSONString(input);
+    expect(result).toBe(false);
+  });
+
+  it("should return false for string with similar but wrong prefix", () => {
+    const input = "data:application/json;utf8,{}";
+    const result = isUTF8JSONString(input);
+    expect(result).toBe(false);
+  });
+});
+
+describe("parseUTF8String", () => {
+  it("should parse UTF-8 string and return the JSON portion", () => {
+    const input = 'data:application/json;utf-8,{"test":"value"}';
+    const result = parseUTF8String(input);
+    expect(result).toBe('{"test":"value"}');
+  });
+
+  it("should parse UTF-8 string with URL-encoded unicode characters", () => {
+    const input =
+      "data:application/json;utf-8,%7B%22name%22%3A%22test%22%2C%22value%22%3A123%7D";
+    const result = parseUTF8String(input);
+    expect(result).toBe('{"name":"test","value":123}');
+  });
+
+  it("should parse UTF-8 string with special characters", () => {
+    const input =
+      'data:application/json;utf-8,{"text":"Hello, World!","special":"@#$%"}';
+    const result = parseUTF8String(input);
+    expect(result).toBe('{"text":"Hello, World!","special":"@#$%"}');
+  });
+
+  it("should parse UTF-8 string with nested JSON", () => {
+    const input =
+      'data:application/json;utf-8,{"outer":{"inner":"value"},"array":[1,2,3]}';
+    const result = parseUTF8String(input);
+    expect(result).toBe('{"outer":{"inner":"value"},"array":[1,2,3]}');
+  });
+
+  it("should parse UTF-8 string with empty JSON object", () => {
+    const input = "data:application/json;utf-8,{}";
+    const result = parseUTF8String(input);
+    expect(result).toBe("{}");
+  });
+
+  it("should parse UTF-8 string with commas in the JSON value", () => {
+    const input = 'data:application/json;utf-8,{"list":"a,b,c"}';
+    const result = parseUTF8String(input);
+    expect(result).toBe('{"list":"a,b,c"}');
+  });
+
+  it("should handle URL-encoded characters", () => {
+    const input = 'data:application/json;utf-8,{"url":"https://example.com"}';
+    const result = parseUTF8String(input);
+    expect(result).toBe('{"url":"https://example.com"}');
+  });
+});

package/src/utils/utf8/utf8.ts

@@ -0,0 +1,40 @@
+const UTF8Prefix = "data:application/json;utf-8" as const;
+type UTF8String = `${typeof UTF8Prefix},${string}`;
+
+/**
+ * Checks if a given string is a UTF-8 encoded JSON string.
+ * @param input - The string to be checked.
+ * @returns True if the input string starts with "data:application/json;utf-8", false otherwise.
+ * @example
+ * ```ts
+ * isUTF8JSONString("data:application/json;utf-8,{ \"test\": \"utf8\" }")
+ * // true
+ * ```
+ */
+export function isUTF8JSONString(input: string): input is UTF8String {
+  if (input.toLowerCase().startsWith(UTF8Prefix)) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Parses a UTF-8 string and returns the decoded string.
+ * @param input - The UTF-8 string to parse.
+ * @returns The decoded string.
+ * @example
+ * ```ts
+ * parseUTF8String("data:application/json;utf-8,{ \"test\": \"utf8\" }")
+ * // '{"test":"utf8"}'
+ * ```
+ */
+export function parseUTF8String(input: UTF8String) {
+  const commaIndex = input.indexOf(",");
+  const utf8 = input.slice(commaIndex + 1);
+  try {
+    // try to decode the UTF-8 string, if it fails, return the original string
+    return decodeURIComponent(utf8);
+  } catch {
+    return utf8;
+  }
+}

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.115.3";
+export const version = "5.115.4";

package/src/wallets/utils/getWalletBalance.ts

@@ -43,7 +43,15 @@ export type GetWalletBalanceResult = GetBalanceResult;
 export async function getWalletBalance(
   options: GetWalletBalanceOptions,
 ): Promise<GetBalanceResult> {
-  const { address, client, chain, tokenAddress } = options;
+  const { address, client, chain } = options;
+
+  // Scipper chain (42429) uses a wrapped native token for balance queries
+  const tokenAddress =
+    options.tokenAddress ||
+    (chain.id === 42429
+      ? "0x20c0000000000000000000000000000000000000"
+      : undefined);
+
   // erc20 case
   if (
     tokenAddress &&