thirdweb 5.63.3-nightly-50f98d7486809c541252a9cfc6979d102960366b-20241022000337 → 5.64.0-nightly-e6e994479fb8386b1740de4170f33446f038f2b1-20241024000332

package/src/analytics/track/siwe.test.ts

@@ -0,0 +1,110 @@
+import { http, HttpResponse } from "msw";
+import { setupServer } from "msw/node";
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import type { ThirdwebClient } from "../../client/client.js";
+import { trackLogin } from "./siwe.js";
+
+const server = setupServer(
+  http.post("https://c.thirdweb.com/event", () => {
+    return HttpResponse.json({});
+  }),
+);
+
+describe("SIWE tracking", () => {
+  beforeAll(() => server.listen());
+  afterEach(() => server.resetHandlers());
+  afterAll(() => server.close());
+
+  const mockClient: ThirdwebClient = {
+    clientId: "test-client-id",
+    secretKey: undefined,
+  };
+
+  it("should track successful logins", async () => {
+    let requestBody: unknown;
+    server.use(
+      http.post("https://c.thirdweb.com/event", async (handler) => {
+        requestBody = await handler.request.json();
+        return HttpResponse.json({});
+      }),
+    );
+
+    await trackLogin({
+      client: mockClient,
+      walletAddress: "0x1234567890123456789012345678901234567890",
+      walletType: "metamask",
+      chainId: 1,
+    });
+
+    expect(requestBody).toEqual({
+      source: "sdk",
+      action: "login:attempt",
+      clientId: "test-client-id",
+      walletAddress: "0x1234567890123456789012345678901234567890",
+      walletType: "metamask",
+      chainId: 1,
+      errorCode: undefined,
+    });
+  });
+
+  it("should track login errors", async () => {
+    let requestBody: unknown;
+    server.use(
+      http.post("https://c.thirdweb.com/event", async (handler) => {
+        requestBody = await handler.request.json();
+        return HttpResponse.json({});
+      }),
+    );
+
+    await trackLogin({
+      client: mockClient,
+      walletAddress: "0x1234567890123456789012345678901234567890",
+      walletType: "metamask",
+      chainId: 1,
+      error: {
+        message: "Signature verification failed",
+        code: "SIGNATURE_VERIFICATION_FAILED",
+      },
+    });
+
+    expect(requestBody).toEqual({
+      source: "sdk",
+      action: "login:attempt",
+      clientId: "test-client-id",
+      walletAddress: "0x1234567890123456789012345678901234567890",
+      walletType: "metamask",
+      chainId: 1,
+      errorCode:
+        '{"message":"Signature verification failed","code":"SIGNATURE_VERIFICATION_FAILED"}',
+    });
+  });
+
+  it("should send a POST request with correct headers", async () => {
+    let requestHeaders: Headers | undefined;
+    server.use(
+      http.post("https://c.thirdweb.com/event", (handler) => {
+        requestHeaders = handler.request.headers;
+        return HttpResponse.json({});
+      }),
+    );
+
+    await trackLogin({
+      client: mockClient,
+      ecosystem: {
+        id: "ecosystem.test-ecosystem-id",
+        partnerId: "test-partner-id",
+      },
+      walletAddress: "0x1234567890123456789012345678901234567890",
+      walletType: "metamask",
+      chainId: 1,
+    });
+
+    expect(requestHeaders?.get("x-client-id")).toEqual("test-client-id");
+    expect(requestHeaders?.get("x-ecosystem-id")).toEqual(
+      "ecosystem.test-ecosystem-id",
+    );
+    expect(requestHeaders?.get("x-ecosystem-partner-id")).toEqual(
+      "test-partner-id",
+    );
+  });
+});

package/src/analytics/track/siwe.ts

@@ -0,0 +1,48 @@
+import type { ThirdwebClient } from "../../client/client.js";
+import { stringify } from "../../utils/json.js";
+import type { Ecosystem } from "../../wallets/in-app/core/wallet/types.js";
+import { track } from "./index.js";
+
+type SiweEvent = {
+  client: ThirdwebClient;
+  ecosystem?: Ecosystem;
+  walletAddress?: string;
+  walletType?: string;
+  chainId?: number;
+  error?: {
+    message: string;
+    code: string;
+  };
+};
+
+/**
+ * @internal
+ */
+export async function trackLogin(event: SiweEvent) {
+  return trackSiweEvent({
+    ...event,
+    action: "login:attempt",
+  });
+}
+
+/**
+ * @internal
+ */
+async function trackSiweEvent(
+  event: SiweEvent & {
+    action: "login:attempt";
+  },
+) {
+  return track({
+    client: event.client,
+    ecosystem: event.ecosystem,
+    data: {
+      action: event.action,
+      clientId: event.client.clientId,
+      chainId: event.chainId,
+      walletAddress: event.walletAddress,
+      walletType: event.walletType,
+      errorCode: stringify(event.error),
+    },
+  });
+}

package/src/analytics/track/track.test.ts

@@ -0,0 +1,107 @@
+import { http, HttpResponse } from "msw";
+import { setupServer } from "msw/node";
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import type { ThirdwebClient } from "../../client/client.js";
+import { track } from "./index.js";
+
+const server = setupServer(
+  http.post("https://c.thirdweb.com/event", () => {
+    return HttpResponse.json({});
+  }),
+);
+
+describe("track", () => {
+  beforeAll(() => server.listen());
+  afterEach(() => server.resetHandlers());
+  afterAll(() => server.close());
+
+  it("should send a POST request with correct data", async () => {
+    const mockClient: ThirdwebClient = {
+      clientId: "test-client-id",
+      secretKey: undefined,
+    };
+
+    let requestBody: unknown;
+    server.use(
+      http.post("https://c.thirdweb.com/event", async (handler) => {
+        requestBody = await handler.request.json();
+        return HttpResponse.json({});
+      }),
+    );
+
+    await track({
+      client: mockClient,
+      data: {
+        action: "test-action",
+        data: "test-data",
+      },
+    });
+
+    expect(requestBody).toEqual({
+      source: "sdk",
+      action: "test-action",
+      data: "test-data",
+    });
+  });
+
+  it("should not throw an error if the request fails", async () => {
+    const mockClient: ThirdwebClient = {
+      clientId: "test-client-id",
+      secretKey: undefined,
+    };
+
+    server.use(
+      http.post("https://c.thirdweb.com/event", () => {
+        return HttpResponse.error();
+      }),
+    );
+
+    expect(() =>
+      track({
+        client: mockClient,
+        data: {
+          action: "test-action",
+          data: "test-data",
+        },
+      }),
+    ).not.toThrowError();
+
+    // Wait for the asynchronous POST request to complete
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  });
+
+  it("should send a POST request with correct headers", async () => {
+    const mockClient: ThirdwebClient = {
+      clientId: "test-client-id",
+      secretKey: undefined,
+    };
+
+    let requestHeaders: Headers | undefined;
+    server.use(
+      http.post("https://c.thirdweb.com/event", (handler) => {
+        requestHeaders = handler.request.headers;
+        return HttpResponse.json({});
+      }),
+    );
+
+    await track({
+      client: mockClient,
+      ecosystem: {
+        id: "ecosystem.test-ecosystem-id",
+        partnerId: "test-partner-id",
+      },
+      data: {
+        action: "test-action",
+        data: "test-data",
+      },
+    });
+
+    expect(requestHeaders?.get("x-client-id")).toEqual("test-client-id");
+    expect(requestHeaders?.get("x-ecosystem-id")).toEqual(
+      "ecosystem.test-ecosystem-id",
+    );
+    expect(requestHeaders?.get("x-ecosystem-partner-id")).toEqual(
+      "test-partner-id",
+    );
+  });
+});

package/src/analytics/track/transaction.test.ts

@@ -0,0 +1,130 @@
+import { http, HttpResponse } from "msw";
+import { setupServer } from "msw/node";
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import type { ThirdwebClient } from "../../client/client.js";
+import { trackTransaction } from "./transaction.js";
+
+const server = setupServer(
+  http.post("https://c.thirdweb.com/event", () => {
+    return HttpResponse.json({});
+  }),
+);
+
+describe("transaction tracking", () => {
+  beforeAll(() => server.listen());
+  afterEach(() => server.resetHandlers());
+  afterAll(() => server.close());
+
+  const mockClient: ThirdwebClient = {
+    clientId: "test-client-id",
+    secretKey: undefined,
+  };
+
+  it("should track successful transactions", async () => {
+    let requestBody: unknown;
+    server.use(
+      http.post("https://c.thirdweb.com/event", async (handler) => {
+        requestBody = await handler.request.json();
+        return HttpResponse.json({});
+      }),
+    );
+
+    await trackTransaction({
+      client: mockClient,
+      transactionHash: "0xabcdef1234567890",
+      walletAddress: "0x1234567890123456789012345678901234567890",
+      walletType: "io.metamask",
+      chainId: 1,
+      contractAddress: "0x0987654321098765432109876543210987654321",
+      functionName: "transfer",
+      gasPrice: BigInt(20000000000),
+    });
+
+    expect(requestBody).toEqual({
+      source: "sdk",
+      action: "transaction:sent",
+      clientId: "test-client-id",
+      transactionHash: "0xabcdef1234567890",
+      walletAddress: "0x1234567890123456789012345678901234567890",
+      walletType: "io.metamask",
+      chainId: 1,
+      contractAddress: "0x0987654321098765432109876543210987654321",
+      functionName: "transfer",
+      gasPrice: "20000000000",
+      errorCode: undefined,
+    });
+  });
+
+  it("should track transaction errors", async () => {
+    let requestBody: unknown;
+    server.use(
+      http.post("https://c.thirdweb.com/event", async (handler) => {
+        requestBody = await handler.request.json();
+        return HttpResponse.json({});
+      }),
+    );
+
+    await trackTransaction({
+      client: mockClient,
+      walletAddress: "0x1234567890123456789012345678901234567890",
+      walletType: "io.metamask",
+      chainId: 1,
+      error: {
+        message: "Insufficient funds",
+        code: "INSUFFICIENT_FUNDS",
+      },
+    });
+
+    expect(requestBody).toEqual({
+      source: "sdk",
+      action: "transaction:sent",
+      clientId: "test-client-id",
+      walletAddress: "0x1234567890123456789012345678901234567890",
+      walletType: "io.metamask",
+      chainId: 1,
+      errorCode: '{"message":"Insufficient funds","code":"INSUFFICIENT_FUNDS"}',
+      transactionHash: undefined,
+      contractAddress: undefined,
+      functionName: undefined,
+      gasPrice: undefined,
+    });
+  });
+
+  it("should send a POST request with correct headers", async () => {
+    const mockClient: ThirdwebClient = {
+      clientId: "test-client-id",
+      secretKey: undefined,
+    };
+
+    let requestHeaders: Headers | undefined;
+    server.use(
+      http.post("https://c.thirdweb.com/event", (handler) => {
+        requestHeaders = handler.request.headers;
+        return HttpResponse.json({});
+      }),
+    );
+
+    await trackTransaction({
+      client: mockClient,
+      ecosystem: {
+        id: "ecosystem.test-ecosystem-id",
+        partnerId: "test-partner-id",
+      },
+      transactionHash: "0xabcdef1234567890",
+      walletAddress: "0x1234567890123456789012345678901234567890",
+      walletType: "io.metamask",
+      chainId: 1,
+      contractAddress: "0x0987654321098765432109876543210987654321",
+      functionName: "transfer",
+      gasPrice: BigInt(20000000000),
+    });
+
+    expect(requestHeaders?.get("x-client-id")).toEqual("test-client-id");
+    expect(requestHeaders?.get("x-ecosystem-id")).toEqual(
+      "ecosystem.test-ecosystem-id",
+    );
+    expect(requestHeaders?.get("x-ecosystem-partner-id")).toEqual(
+      "test-partner-id",
+    );
+  });
+});

package/src/analytics/track/transaction.ts

@@ -0,0 +1,57 @@
+import type { ThirdwebClient } from "../../client/client.js";
+import { stringify } from "../../utils/json.js";
+import type { Ecosystem } from "../../wallets/in-app/core/wallet/types.js";
+import type { WalletId } from "../../wallets/wallet-types.js";
+import { track } from "./index.js";
+
+type TransactionEvent = {
+  client: ThirdwebClient;
+  ecosystem?: Ecosystem;
+  transactionHash?: string;
+  walletAddress?: string;
+  walletType?: WalletId;
+  chainId?: number;
+  contractAddress?: string;
+  functionName?: string;
+  gasPrice?: bigint;
+  error?: {
+    message: string;
+    code: string;
+  };
+};
+
+/**
+ * @internal
+ */
+export async function trackTransaction(args: TransactionEvent) {
+  return trackTransactionEvent({
+    ...args,
+    action: "transaction:sent",
+  });
+}
+
+/**
+ * @internal
+ */
+function trackTransactionEvent(
+  args: TransactionEvent & {
+    action: "transaction:sent";
+  },
+) {
+  return track({
+    client: args.client,
+    ecosystem: args.ecosystem,
+    data: {
+      action: args.action,
+      clientId: args.client.clientId,
+      chainId: args.chainId,
+      transactionHash: args.transactionHash,
+      walletAddress: args.walletAddress,
+      walletType: args.walletType,
+      contractAddress: args.contractAddress,
+      functionName: args.functionName,
+      gasPrice: args.gasPrice,
+      errorCode: stringify(args.error),
+    },
+  });
+}

package/src/auth/core/verify-login-payload.ts

@@ -1,3 +1,4 @@
+import { trackLogin } from "../../analytics/track/siwe.js";
 import { getCachedChain } from "../../chains/utils.js";
 import { verifySignature } from "../verify-signature.js";
 import { DEFAULT_LOGIN_STATEMENT, DEFAULT_LOGIN_VERSION } from "./constants.js";
@@ -42,7 +43,7 @@ export type VerifyLoginPayloadResult =
  * @internal
  */
 export function verifyLoginPayload(options: AuthOptions) {
-  return async ({
+  const verifyLoginPayloadFn = async ({
     payload,
     signature,
   }: VerifyLoginPayloadParams): Promise<VerifyLoginPayloadResult> => {
@@ -152,4 +153,27 @@ export function verifyLoginPayload(options: AuthOptions) {
       payload: { ...payload, [VERIFIED_SYMBOL]: true },
     };
   };
+
+  return async ({
+    payload,
+    signature,
+  }: VerifyLoginPayloadParams): Promise<VerifyLoginPayloadResult> => {
+    const result = await verifyLoginPayloadFn({ payload, signature });
+
+    // We can only track logins if the client is provided
+    if (options.client) {
+      trackLogin({
+        client: options.client,
+        walletAddress: payload.address,
+        chainId: payload.chain_id
+          ? Number.parseInt(payload.chain_id)
+          : undefined,
+        error: !result.valid
+          ? { message: result.error, code: "401" }
+          : undefined,
+      });
+    }
+
+    return result;
+  };
 }

package/src/exports/extensions/erc1155.ts

@@ -203,3 +203,8 @@ export {
   mintToBatch,
   type MintToBatchParams,
 } from "../../extensions/erc1155/write/mintToBatch.js";
+
+export {
+  mintAdditionalSupplyToBatch,
+  type MintAdditionalSupplyToBatchParams,
+} from "../../extensions/erc1155/write/mintAdditionalSupplyToBatch.js";

package/src/exports/extensions/erc721.ts

@@ -213,3 +213,7 @@ export {
   type UpdateTokenURIParams,
   isUpdateTokenURISupported,
 } from "../../extensions/erc721/write/updateTokenURI.js";
+export {
+  claimToBatch,
+  type ClaimToBatchParams,
+} from "../../extensions/erc721/drops/write/claimToBatch.js";

package/src/exports/wallets/in-app.ts

@@ -21,4 +21,7 @@ export type {
 
 export { hasStoredPasskey } from "../../wallets/in-app/web/lib/auth/passkeys.js";
 
-export { socialIcons } from "../../react/core/utils/walletIcon.js";
+export {
+  socialIcons,
+  getSocialIcon,
+} from "../../react/core/utils/walletIcon.js";

package/src/extensions/erc1155/drop1155.test.ts

@@ -1,3 +1,4 @@
+import { type Abi, toFunctionSelector } from "viem";
 import { beforeAll, describe, expect, it } from "vitest";
 import { TEST_CONTRACT_URI } from "~test/ipfs-uris.js";
 import { VITALIK_WALLET } from "../../../test/src/addresses.js";
@@ -8,6 +9,7 @@ import {
   TEST_ACCOUNT_B,
   TEST_ACCOUNT_D,
 } from "../../../test/src/test-wallets.js";
+import { resolveContractAbi } from "../../contract/actions/resolve-abi.js";
 import { type ThirdwebContract, getContract } from "../../contract/contract.js";
 import { sendAndConfirmTransaction } from "../../transaction/actions/send-and-confirm-transaction.js";
 import { resolvePromisedValue } from "../../utils/promise/resolve-promised-value.js";
@@ -20,6 +22,7 @@ import { claimTo } from "./drops/write/claimTo.js";
 import { resetClaimEligibility } from "./drops/write/resetClaimEligibility.js";
 import { setClaimConditions } from "./drops/write/setClaimConditions.js";
 import { getNFT } from "./read/getNFT.js";
+import { isGetNFTsSupported } from "./read/getNFTs.js";
 import { lazyMint } from "./write/lazyMint.js";
 
 describe.runIf(process.env.TW_SECRET_KEY)(
@@ -398,5 +401,13 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         balanceOf({ tokenId: 6n, contract, owner: TEST_ACCOUNT_D.address }),
       ).resolves.toBe(2n);
     });
+
+    it("isGetNFTsSupported should work with our Edition Drop contracts", async () => {
+      const abi = await resolveContractAbi<Abi>(contract);
+      const selectors = abi
+        .filter((f) => f.type === "function")
+        .map((f) => toFunctionSelector(f));
+      expect(isGetNFTsSupported(selectors)).toBe(true);
+    });
   },
 );