fix(utils): reject whitespace in decodeTokenIds with helpful error

src/constants.ts

@@ -80,9 +80,9 @@ const SHARED_STOREFRONT_ADDRESS_MAINNET =
   "0x495f947276749ce646f68ac8c248420045cb7b5e";
 const SHARED_STOREFRONT_ADDRESS_POLYGON =
   "0x2953399124f0cbb46d2cbacd8a89cf0599974963";
-export const SHARED_STOREFRONT_ADDRESSES = [
+export const SHARED_STOREFRONT_ADDRESSES = new Set([
   SHARED_STOREFRONT_ADDRESS_MAINNET,
   SHARED_STOREFRONT_ADDRESS_POLYGON,
-].map((address) => address.toLowerCase());
+]);
 export const SHARED_STOREFRONT_LAZY_MINT_ADAPTER_CROSS_CHAIN_ADDRESS =
   "0xa604060890923ff400e8c6f5290461a83aedacec";

src/utils/protocol.ts

@@ -47,9 +47,17 @@ export const getAssetItemType = (tokenStandard: TokenStandard) => {
  *          otherwise returns the original address unchanged
  */
 export const remapSharedStorefrontAddress = (tokenAddress: string): string => {
-  return SHARED_STOREFRONT_ADDRESSES.includes(tokenAddress.toLowerCase())
-    ? SHARED_STOREFRONT_LAZY_MINT_ADAPTER_CROSS_CHAIN_ADDRESS
-    : tokenAddress;
+  try {
+    const lowercased = tokenAddress.toLowerCase();
+    if (SHARED_STOREFRONT_ADDRESSES.has(lowercased)) {
+      return ethers.getAddress(
+        SHARED_STOREFRONT_LAZY_MINT_ADAPTER_CROSS_CHAIN_ADDRESS,
+      );
+    }
+    return ethers.getAddress(tokenAddress);
+  } catch {
+    return tokenAddress;
+  }
 };
 
 /**
@@ -137,6 +145,13 @@ export const decodeTokenIds = (encodedTokenIds: string): string[] => {
     return [];
   }
 
+  // Check for whitespace and provide helpful error message
+  if (/\s/.test(encodedTokenIds)) {
+    throw new Error(
+      "Invalid input format: whitespace is not allowed. Expected format: '1,2,3' or '1:5' or '1,3:5,8' (no spaces).",
+    );
+  }
+
   const validFormatRegex = /^(\d+(:\d+)?)(,\d+(:\d+)?)*$/;
 
   if (!validFormatRegex.test(encodedTokenIds)) {

test/sdk/misc.spec.ts

@@ -22,25 +22,21 @@ suite("SDK: misc", () => {
     assert.equal(typeof sdk.api.getOrders, "function");
   });
 
-  test("Checks that a non-shared storefront address is not remapped", async () => {
+  test("Checks that a non-shared storefront address is checksummed", async () => {
     const address = BAYC_CONTRACT_ADDRESS;
-    assert.equal(remapSharedStorefrontAddress(address), address);
+    assert.equal(
+      remapSharedStorefrontAddress(address),
+      ethers.getAddress(address),
+    );
   });
 
-  test("Checks that shared storefront addresses are remapped to lazy mint adapter address", async () => {
+  test("Checks that shared storefront addresses are remapped to checksummed lazy mint adapter address", async () => {
     for (const address of SHARED_STOREFRONT_ADDRESSES) {
       assert.equal(
         remapSharedStorefrontAddress(address),
-        SHARED_STOREFRONT_LAZY_MINT_ADAPTER_CROSS_CHAIN_ADDRESS,
-      );
-    }
-  });
-
-  test("Checks that upper case shared storefront addresses are remapped to lazy mint adapter address", async () => {
-    for (const address of SHARED_STOREFRONT_ADDRESSES) {
-      assert.equal(
-        remapSharedStorefrontAddress(address.toUpperCase()),
-        SHARED_STOREFRONT_LAZY_MINT_ADAPTER_CROSS_CHAIN_ADDRESS,
+        ethers.getAddress(
+          SHARED_STOREFRONT_LAZY_MINT_ADAPTER_CROSS_CHAIN_ADDRESS,
+        ),
       );
     }
   });

test/utils/protocol.spec.ts

@@ -112,29 +112,21 @@ suite("Utils: protocol", () => {
   });
 
   suite("remapSharedStorefrontAddress", () => {
-    test("returns lazy mint adapter address for shared storefront address", () => {
+    test("returns checksummed lazy mint adapter address for shared storefront address", () => {
       for (const sharedStorefrontAddress of SHARED_STOREFRONT_ADDRESSES) {
         const result = remapSharedStorefrontAddress(sharedStorefrontAddress);
         expect(result).to.equal(
-          SHARED_STOREFRONT_LAZY_MINT_ADAPTER_CROSS_CHAIN_ADDRESS,
+          ethers.getAddress(
+            SHARED_STOREFRONT_LAZY_MINT_ADAPTER_CROSS_CHAIN_ADDRESS,
+          ),
         );
       }
     });
 
-    test("returns lazy mint adapter address for uppercase shared storefront address", () => {
-      for (const sharedStorefrontAddress of SHARED_STOREFRONT_ADDRESSES) {
-        const upperCaseAddress = sharedStorefrontAddress.toUpperCase();
-        const result = remapSharedStorefrontAddress(upperCaseAddress);
-        expect(result).to.equal(
-          SHARED_STOREFRONT_LAZY_MINT_ADAPTER_CROSS_CHAIN_ADDRESS,
-        );
-      }
-    });
-
-    test("returns original address for non-shared storefront address", () => {
+    test("returns checksummed address for non-shared storefront address", () => {
       const randomAddress = ethers.Wallet.createRandom().address;
       const result = remapSharedStorefrontAddress(randomAddress);
-      expect(result).to.equal(randomAddress);
+      expect(result).to.equal(ethers.getAddress(randomAddress));
     });
   });
 
@@ -219,6 +211,18 @@ suite("Utils: protocol", () => {
     test("correctly decodes range where start = end", () => {
       expect(decodeTokenIds("5:5")).to.deep.equal(["5"]);
     });
+
+    test("throws error for input with whitespace", () => {
+      expect(() => decodeTokenIds(" 1, 3:5, 8 ")).to.throw(
+        "whitespace is not allowed",
+      );
+      expect(() => decodeTokenIds("1 : 3")).to.throw(
+        "whitespace is not allowed",
+      );
+      expect(() => decodeTokenIds("1, 2")).to.throw(
+        "whitespace is not allowed",
+      );
+    });
   });
 
   suite("getSeaportInstance", () => {