thirdweb 5.64.0-nightly-cdb907f175f7472d1fb3dea6547d946514564085-20241023000322 → 5.64.0-nightly-e6e994479fb8386b1740de4170f33446f038f2b1-20241024000332

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/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);
+    });
   },
 );

package/src/extensions/erc1155/token1155.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 { ANVIL_CHAIN } from "../../../test/src/chains.js";
@@ -5,17 +6,27 @@ import { TEST_CLIENT } from "../../../test/src/test-clients.js";
 import {
   TEST_ACCOUNT_A,
   TEST_ACCOUNT_B,
+  TEST_ACCOUNT_C,
 } 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 { deployERC1155Contract } from "../prebuilts/deploy-erc1155.js";
 import { balanceOf } from "./__generated__/IERC1155/read/balanceOf.js";
 import { totalSupply } from "./__generated__/IERC1155/read/totalSupply.js";
+import { uri } from "./__generated__/IERC1155/read/uri.js";
 import { nextTokenIdToMint } from "./__generated__/IERC1155Enumerable/read/nextTokenIdToMint.js";
 import { getNFT } from "./read/getNFT.js";
-import { getNFTs } from "./read/getNFTs.js";
-import { mintAdditionalSupplyTo } from "./write/mintAdditionalSupplyTo.js";
+import { getNFTs, isGetNFTsSupported } from "./read/getNFTs.js";
+import { getOwnedTokenIds } from "./read/getOwnedTokenIds.js";
+import {
+  isMintAdditionalSupplyToSupported,
+  mintAdditionalSupplyTo,
+} from "./write/mintAdditionalSupplyTo.js";
+import { mintAdditionalSupplyToBatch } from "./write/mintAdditionalSupplyToBatch.js";
 import { mintTo } from "./write/mintTo.js";
+import { mintToBatch } from "./write/mintToBatch.js";
+import { updateTokenURI } from "./write/updateTokenURI.js";
 
 describe.runIf(process.env.TW_SECRET_KEY)("TokenERC1155", () => {
   let contract: ThirdwebContract;
@@ -158,4 +169,161 @@ describe.runIf(process.env.TW_SECRET_KEY)("TokenERC1155", () => {
       ]
     `);
   });
+
+  it("isGetNFTsSupported should work with our Edition 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);
+  });
+
+  // tokenId #0 is updated in this test
+  it("should update tokenURI", async () => {
+    await sendAndConfirmTransaction({
+      transaction: updateTokenURI({
+        contract,
+        newMetadata: { name: "Test1 Updated" },
+        tokenId: 0n,
+      }),
+      account: TEST_ACCOUNT_A,
+    });
+    const nft = await getNFT({ contract, tokenId: 0n });
+    expect(nft.metadata.name).toBe("Test1 Updated");
+  });
+
+  it("should mint with `nft` being declared as a string", async () => {
+    await sendAndConfirmTransaction({
+      transaction: mintTo({
+        contract,
+        nft: TEST_CONTRACT_URI,
+        to: TEST_ACCOUNT_A.address,
+        supply: 1n,
+      }),
+      account: TEST_ACCOUNT_A,
+    });
+
+    const tokenUri = await uri({ contract, tokenId: 2n });
+    expect(tokenUri).toBe(TEST_CONTRACT_URI);
+  });
+
+  it("`isMintAdditionalSupplyToSupported` should work with our Edition contracts", async () => {
+    const abi = await resolveContractAbi<Abi>(contract);
+    const selectors = abi
+      .filter((f) => f.type === "function")
+      .map((f) => toFunctionSelector(f));
+    expect(isMintAdditionalSupplyToSupported(selectors)).toBe(true);
+  });
+
+  it("should mint multiple tokens in one tx", async () => {
+    await sendAndConfirmTransaction({
+      account: TEST_ACCOUNT_A,
+      transaction: mintToBatch({
+        contract,
+        to: TEST_ACCOUNT_C.address,
+        nfts: [
+          { metadata: { name: "batch token 0" }, supply: 1n },
+          { metadata: { name: "batch token 1" }, supply: 2n },
+          { metadata: { name: "batch token 2" }, supply: 3n },
+        ],
+      }),
+    });
+
+    const nfts = await getNFTs({ contract });
+    expect(nfts).toStrictEqual([
+      {
+        // Updated tokenURI from the test above
+        metadata: { name: "Test1 Updated" },
+        owner: null,
+        id: 0n,
+        tokenURI: "ipfs://QmTSyt6YgoFtH8yhWgevC22BxjyrkCKuzdk86nqQJCwrV9/0",
+        type: "ERC1155",
+        supply: 15n,
+      },
+      {
+        metadata: { name: "Test NFT 2" },
+        owner: null,
+        id: 1n,
+        tokenURI: "ipfs://QmV6gsfzdiMRtpnh8ay3CgutStVbes7qoF4DKpYE64h8hT/0",
+        type: "ERC1155",
+        supply: 5n,
+      },
+      {
+        metadata: {
+          name: "tw-contract-name",
+          symbol: "tw-contract-symbol",
+          description: "tw-contract-description",
+        },
+        owner: null,
+        id: 2n,
+        // Minted using URI from the test above
+        tokenURI:
+          "ipfs://bafybeiewg2e3vehsb5pb34xwk25eyyfwlvajzmgz3rtdrvn3upsxnsbhzi/contractUri.json",
+        type: "ERC1155",
+        supply: 1n,
+      },
+      {
+        metadata: { name: "batch token 0" },
+        owner: null,
+        id: 3n,
+        tokenURI: "ipfs://QmPSQhC2J6Wig4pH1Lt5th19FM58J5oukhfLfpc9L1i39Q/0",
+        type: "ERC1155",
+        supply: 1n,
+      },
+      {
+        metadata: { name: "batch token 1" },
+        owner: null,
+        id: 4n,
+        tokenURI: "ipfs://QmWRQwLBAeq6Wr65Yj7A4aeYqMD1C7Hs1moz15ncS6EhGu/0",
+        type: "ERC1155",
+        supply: 2n,
+      },
+      {
+        metadata: { name: "batch token 2" },
+        owner: null,
+        id: 5n,
+        tokenURI: "ipfs://QmTg1wxKGvdZR4NrdkYZGcfB5YYaBz75DH83td5RwprMRP/0",
+        type: "ERC1155",
+        supply: 3n,
+      },
+    ]);
+  });
+
+  it("getOwnedTokenIds should work", async () => {
+    const ownedTokenIds = await getOwnedTokenIds({
+      contract,
+      address: TEST_ACCOUNT_C.address,
+    });
+    expect(ownedTokenIds).toStrictEqual([
+      { tokenId: 3n, balance: 1n },
+      { tokenId: 4n, balance: 2n },
+      { tokenId: 5n, balance: 3n },
+    ]);
+  });
+
+  it("should mint multiple ADDITIONAL tokens in one tx", async () => {
+    await sendAndConfirmTransaction({
+      account: TEST_ACCOUNT_A,
+      transaction: mintAdditionalSupplyToBatch({
+        contract,
+        nfts: [
+          { tokenId: 3n, supply: 99n, to: TEST_ACCOUNT_C.address },
+          { tokenId: 4n, supply: 94n, to: TEST_ACCOUNT_C.address },
+          { tokenId: 5n, supply: 97n, to: TEST_ACCOUNT_C.address },
+          { tokenId: 3n, supply: 4n, to: TEST_ACCOUNT_C.address },
+        ],
+      }),
+    });
+
+    const ownedTokenIds = await getOwnedTokenIds({
+      contract,
+      address: TEST_ACCOUNT_C.address,
+    });
+
+    expect(ownedTokenIds).toStrictEqual([
+      { tokenId: 3n, balance: 104n },
+      { tokenId: 4n, balance: 96n },
+      { tokenId: 5n, balance: 100n },
+    ]);
+  });
 });

package/src/extensions/erc1155/write/lazyMint.test.ts

@@ -1,32 +1,12 @@
 import { type Abi, toFunctionSelector } from "viem";
 import { describe, expect, it } from "vitest";
-import { ANVIL_CHAIN } from "~test/chains.js";
-import { TEST_CONTRACT_URI } from "~test/ipfs-uris.js";
-import { TEST_CLIENT } from "~test/test-clients.js";
-import { TEST_ACCOUNT_C } from "~test/test-wallets.js";
+import { DROP1155_CONTRACT } from "~test/test-contracts.js";
 import { resolveContractAbi } from "../../../contract/actions/resolve-abi.js";
-import { getContract } from "../../../contract/contract.js";
-import { deployERC1155Contract } from "../../../extensions/prebuilts/deploy-erc1155.js";
 import { isLazyMintSupported } from "./lazyMint.js";
 
 describe.runIf(process.env.TW_SECRET_KEY)("erc1155: lazyMint", () => {
   it("`isLazyMintSupported` should work with our Edition Drop contracts", async () => {
-    const contract = getContract({
-      address: await deployERC1155Contract({
-        chain: ANVIL_CHAIN,
-        client: TEST_CLIENT,
-        params: {
-          name: "",
-          contractURI: TEST_CONTRACT_URI,
-        },
-        type: "DropERC1155",
-        account: TEST_ACCOUNT_C,
-      }),
-      chain: ANVIL_CHAIN,
-      client: TEST_CLIENT,
-    });
-
-    const abi = await resolveContractAbi<Abi>(contract);
+    const abi = await resolveContractAbi<Abi>(DROP1155_CONTRACT);
     const selectors = abi
       .filter((f) => f.type === "function")
       .map((f) => toFunctionSelector(f));