thirdweb 5.59.2 → 5.60.0-nightly-6c26012a71d884f99dd5d8c914b3879037b36d56-20240929000339

package/src/extensions/pack/createNewPack.test.ts

@@ -0,0 +1,207 @@
+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_A } from "~test/test-wallets.js";
+import { getContract } from "../../contract/contract.js";
+import { download } from "../../storage/download.js";
+import { sendAndConfirmTransaction } from "../../transaction/actions/send-and-confirm-transaction.js";
+import { balanceOf as balanceOfERC20 } from "../erc20/__generated__/IERC20/read/balanceOf.js";
+import { approve } from "../erc20/write/approve.js";
+import { mintTo as mintToERC20 } from "../erc20/write/mintTo.js";
+import { balanceOf as balanceOfERC721 } from "../erc721/__generated__/IERC721A/read/balanceOf.js";
+import { ownerOf } from "../erc721/__generated__/IERC721A/read/ownerOf.js";
+import { setApprovalForAll } from "../erc721/__generated__/IERC721A/write/setApprovalForAll.js";
+import { mintTo as mintToERC721 } from "../erc721/write/mintTo.js";
+import { openPack } from "../erc1155/__generated__/IPack/write/openPack.js";
+import { getPackContents } from "../pack/__generated__/IPack/read/getPackContents.js";
+import { getTokenCountOfBundle } from "../pack/__generated__/IPack/read/getTokenCountOfBundle.js";
+import { getUriOfBundle } from "../pack/__generated__/IPack/read/getUriOfBundle.js";
+import { deployERC20Contract } from "../prebuilts/deploy-erc20.js";
+import { deployERC721Contract } from "../prebuilts/deploy-erc721.js";
+import { deployPackContract } from "../prebuilts/deploy-pack.js";
+import { createNewPack } from "./createNewPack.js";
+
+const account = TEST_ACCOUNT_A;
+const client = TEST_CLIENT;
+const chain = ANVIL_CHAIN;
+
+describe.runIf(process.env.TW_SECRET_KEY)("createPack", () => {
+  it("should create a Pack and open it to receive rewards", async () => {
+    const packAddress = await deployPackContract({
+      account,
+      client,
+      chain,
+      params: {
+        name: "pack-contract",
+      },
+    });
+
+    const packContract = getContract({
+      address: packAddress,
+      chain,
+      client,
+    });
+
+    const erc20Address = await deployERC20Contract({
+      client: TEST_CLIENT,
+      chain: ANVIL_CHAIN,
+      account: TEST_ACCOUNT_A,
+      type: "TokenERC20",
+      params: {
+        name: "Token",
+        contractURI: TEST_CONTRACT_URI,
+      },
+    });
+
+    const erc20Contract = getContract({ address: erc20Address, chain, client });
+
+    const erc721Address = await deployERC721Contract({
+      client: TEST_CLIENT,
+      chain: ANVIL_CHAIN,
+      account: TEST_ACCOUNT_A,
+      type: "TokenERC721",
+      params: {
+        name: "NFTCollection",
+        contractURI: TEST_CONTRACT_URI,
+      },
+    });
+
+    const erc721Contract = getContract({
+      address: erc721Address,
+      chain,
+      client,
+    });
+    // Mint some ERC20 tokens
+    await sendAndConfirmTransaction({
+      transaction: mintToERC20({
+        contract: erc20Contract,
+        to: account.address,
+        amount: "100",
+      }),
+      account,
+    });
+
+    // Set allowance for Pack contract
+    await sendAndConfirmTransaction({
+      transaction: approve({
+        contract: erc20Contract,
+        amount: "1000000000000000",
+        spender: packContract.address,
+      }),
+      account,
+    });
+
+    // Mint some ERC721 tokens
+    await sendAndConfirmTransaction({
+      transaction: mintToERC721({
+        contract: erc721Contract,
+        to: account.address,
+        nft: { name: "token #0" },
+      }),
+      account,
+    });
+
+    // set erc721 approval
+    await sendAndConfirmTransaction({
+      transaction: setApprovalForAll({
+        contract: erc721Contract,
+        approved: true,
+        operator: packContract.address,
+      }),
+      account,
+    });
+
+    // Create pack
+    await sendAndConfirmTransaction({
+      transaction: createNewPack({
+        contract: packContract,
+        erc20Rewards: [
+          {
+            contractAddress: erc20Contract.address,
+            totalRewards: 1,
+            quantityPerReward: 1,
+          },
+        ],
+        erc721Rewards: [
+          { contractAddress: erc721Contract.address, tokenId: 0n },
+        ],
+        client,
+        packMetadata: {
+          name: "Pack #0",
+        },
+        recipient: account.address,
+        tokenOwner: account.address,
+        openStartTimestamp: new Date(),
+        amountDistributedPerOpen: 1n,
+      }),
+      account,
+    });
+
+    // Read the info of the new Pack
+    const [
+      packContent,
+      tokenCountOfBundle,
+      bundleUri,
+      erc20BalanceAfterCreatePack,
+      erc721BalanceAfterCreatePack,
+    ] = await Promise.all([
+      getPackContents({ contract: packContract, packId: 0n }),
+      getTokenCountOfBundle({ contract: packContract, bundleId: 0n }),
+      getUriOfBundle({ contract: packContract, bundleId: 0n }),
+      balanceOfERC20({ contract: erc20Contract, address: account.address }),
+      balanceOfERC721({ contract: erc721Contract, owner: account.address }),
+    ]);
+
+    // After this, the account should have 99 ERC20 tokens, and 0 (zero) ERC721 token
+    expect(erc20BalanceAfterCreatePack).toBe(99n * 10n ** 18n);
+    expect(erc721BalanceAfterCreatePack).toBe(0n);
+
+    // Make sure the content is correct
+    expect(packContent).toStrictEqual([
+      [
+        {
+          assetContract: erc20Contract.address,
+          tokenType: 0,
+          tokenId: 0n,
+          totalAmount: 1000000000000000000n,
+        },
+        {
+          assetContract: erc721Contract.address,
+          tokenType: 1,
+          tokenId: 0n,
+          totalAmount: 1n,
+        },
+      ],
+      [1000000000000000000n, 1n],
+    ]);
+    expect(tokenCountOfBundle).toBe(2n);
+
+    // Make sure the Pack metadata is correct
+    expect(bundleUri).toBeDefined();
+    const metadata = await (await download({ client, uri: bundleUri })).json();
+    expect(metadata?.name).toBe("Pack #0");
+
+    // Make sure you can open the Pack, since the open-date was set to "now"
+    await sendAndConfirmTransaction({
+      account,
+      transaction: openPack({
+        contract: packContract,
+        packId: 0n,
+        amountToOpen: 1n,
+      }),
+    });
+
+    const [erc20Balance, erc721Owner] = await Promise.all([
+      balanceOfERC20({ contract: erc20Contract, address: account.address }),
+      ownerOf({ contract: erc721Contract, tokenId: 0n }),
+    ]);
+
+    // Since opening a Pack gives "random" rewards, in this case we can check if
+    // the recipient received either 1. <one ERC20 token>, or 2. <one ERC721 token>
+    expect(
+      erc20Balance === 100n * 10n ** 18n ||
+        erc721Owner.toLowerCase() === account.address.toLowerCase(),
+    ).toBe(true);
+  });
+});

package/src/extensions/pack/createNewPack.ts

@@ -0,0 +1,433 @@
+import type { ThirdwebClient } from "../../client/client.js";
+import { type ThirdwebContract, getContract } from "../../contract/contract.js";
+import { upload } from "../../storage/upload.js";
+import type { BaseTransactionOptions } from "../../transaction/types.js";
+import type { NFTInput } from "../../utils/nft/parseNft.js";
+import { toUnits } from "../../utils/units.js";
+import type { AddPackContentsParams } from "./__generated__/IPack/write/addPackContents.js";
+import {
+  type CreatePackParams,
+  createPack,
+} from "./__generated__/IPack/write/createPack.js";
+
+export enum PACK_TOKEN_TYPE {
+  ERC20 = 0,
+  ERC721 = 1,
+  ERC1155 = 2,
+}
+
+export type ERC20Reward = {
+  contractAddress: string;
+  quantityPerReward: number | string;
+  totalRewards: number | string;
+};
+
+export type ERC721Reward = {
+  contractAddress: string;
+  tokenId: bigint;
+};
+
+export type ERC1155Reward = {
+  contractAddress: string;
+  tokenId: bigint;
+  quantityPerReward: number | string;
+  totalRewards: number | string;
+};
+
+/**
+ * @extension PACK
+ */
+export type CreateNewPackParams = {
+  client: ThirdwebClient;
+  contract: ThirdwebContract;
+  /**
+   * The address of the reward recipient
+   */
+  recipient: string;
+  /**
+   * The address of the entity who owns the tokens that are used as rewards.
+   * This is only used for checking token approval
+   */
+  tokenOwner: string;
+  /**
+   * The metadata (image, description, etc.) of the Pack.
+   * This is similar to an NFT's metadata
+   */
+  packMetadata: NFTInput | string;
+  amountDistributedPerOpen: bigint;
+  /**
+   * JavaScript Date object
+   */
+  openStartTimestamp: Date;
+  /**
+   * An array of ERC20 rewards, see type `ERC20Reward` for more info
+   */
+  erc20Rewards?: ERC20Reward[];
+  /**
+   * An array of ERC721 rewards, see type `ERC721Reward` for more info
+   */
+  erc721Rewards?: ERC721Reward[];
+  /**
+   * An array of ERC1155 rewards, see type `ERC1155Reward` for more info
+   */
+  erc1155Rewards?: ERC1155Reward[];
+};
+
+/**
+ * @extension PACK
+ * @example
+ * ```ts
+ * import { createNewPack } from "thirdweb/extensions/pack";
+ *
+ * const transaction = createNewPack({
+ *   contract: packContract,
+ *   client,
+ *   recipient: "0x...",
+ *   tokenOwner: "0x...",
+ *   packMetadata: {
+ *     name: "Pack #1",
+ *     image: "image-of-pack-1",
+ *   },
+ *   openStartTimestamp: new Date(),
+ *   erc20Rewards: [
+ *     {
+ *       contractAddress: "0x...",
+ *       quantityPerReward: 1,
+ *       totalRewards: 1,
+ *     },
+ *   ],
+ *   erc721Rewards: [
+ *     {
+ *       contractAddress: "0x...",
+ *       tokenId: 0n,
+ *     },
+ *   ],
+ *   erc1155Rewards: [
+ *     {
+ *       contractAddress: "0x...",
+ *       tokenId: 0n,
+ *       quantityPerReward: 1,
+ *       totalRewards: 1,
+ *     },
+ *   ],
+ * });
+ * ```
+ */
+export function createNewPack(
+  options: BaseTransactionOptions<CreateNewPackParams>,
+) {
+  return createPack({
+    contract: options.contract,
+    asyncParams: async () => getCreatePackParams(options),
+  });
+}
+
+/**
+ * @internal
+ */
+async function getCreatePackParams(
+  options: BaseTransactionOptions<CreateNewPackParams>,
+): Promise<CreatePackParams> {
+  const {
+    contract,
+    recipient,
+    packMetadata,
+    amountDistributedPerOpen,
+    openStartTimestamp,
+    erc20Rewards,
+    erc721Rewards,
+    erc1155Rewards,
+    tokenOwner,
+  } = options;
+  const [erc20Content, erc721Content, erc1155Content, packUri] =
+    await Promise.all([
+      processErc20Rewards({
+        packContract: contract,
+        content: erc20Rewards,
+        tokenOwner,
+      }),
+      processErc721Rewards({
+        packContract: contract,
+        content: erc721Rewards,
+        tokenOwner,
+      }),
+      processErc1155Rewards({
+        packContract: contract,
+        content: erc1155Rewards,
+        tokenOwner,
+      }),
+      typeof packMetadata === "string"
+        ? packMetadata
+        : upload({
+            client: options.contract.client,
+            files: [packMetadata],
+          }),
+    ]);
+  const contents = erc20Content.content
+    .concat(erc721Content.content)
+    .concat(erc1155Content.content);
+
+  const numOfRewardUnits = erc20Content.numOfRewardUnits
+    .concat(erc721Content.numOfRewardUnits)
+    .concat(erc1155Content.numOfRewardUnits);
+
+  return {
+    packUri,
+    recipient,
+    contents,
+    numOfRewardUnits,
+    // openStartTimestamp should be in seconds and not millisecond
+    openStartTimestamp: BigInt(Math.ceil(openStartTimestamp.getTime() / 1000)),
+    amountDistributedPerOpen,
+  };
+}
+
+/**
+ * @internal
+ */
+async function processErc20Rewards(options: {
+  content?: ERC20Reward[];
+  packContract: ThirdwebContract;
+  tokenOwner: string;
+}): Promise<{
+  content: AddPackContentsParams["contents"];
+  numOfRewardUnits: bigint[];
+}> {
+  const { content, packContract, tokenOwner } = options;
+  if (!content?.length) {
+    return {
+      content: [],
+      numOfRewardUnits: [],
+    };
+  }
+  const [{ allowance }, { decimals }] = await Promise.all([
+    import("../erc20/__generated__/IERC20/read/allowance.js"),
+    import("../erc20/__generated__/IERC20/read/decimals.js"),
+  ]);
+
+  const uniqueERC20Contracts = [
+    ...new Set(
+      content.map((o) =>
+        getContract({
+          address: o.contractAddress,
+          chain: packContract.chain,
+          client: packContract.client,
+        }),
+      ),
+    ),
+  ];
+
+  const data: Array<{
+    _allowance: bigint;
+    _decimals: number;
+    address: string;
+  }> = (
+    await Promise.all(
+      uniqueERC20Contracts.map((contract) => {
+        return Promise.all([
+          allowance({
+            contract,
+            spender: packContract.address,
+            owner: tokenOwner,
+          }),
+          decimals({ contract }).catch(() => undefined),
+          contract.address,
+        ]);
+      }),
+    )
+  ).map((item) => {
+    const [_allowance, _decimals, address] = item;
+    if (_decimals === undefined) {
+      throw new Error(
+        `Failed to get the decimals of contract: ${address}. Make sure it is a valid ERC20 contract`,
+      );
+    }
+    return {
+      _allowance,
+      _decimals,
+      address,
+    };
+  });
+  const numOfRewardUnits: bigint[] = [];
+  const result = content.map((item, index) => {
+    const { contractAddress, quantityPerReward, totalRewards } = item;
+    if (!totalRewards) {
+      throw new Error(
+        `Invalid totalRewards for contract: ${contractAddress} at index: ${index}`,
+      );
+    }
+    const _data = data.find((o) => o.address === contractAddress);
+    if (!_data) {
+      // This should never happen
+      throw new Error(`contractAddress not found: ${contractAddress}`);
+    }
+    const quantityInWei = toUnits(String(quantityPerReward), _data._decimals);
+    const totalRequired = quantityInWei * BigInt(totalRewards);
+    if (totalRequired > _data._allowance) {
+      throw new Error(
+        `The following ERC20 contract address do not have enough allowance for the Pack contract: ${contractAddress}`,
+      );
+    }
+    numOfRewardUnits.push(BigInt(item.totalRewards));
+    return {
+      assetContract: contractAddress,
+      tokenType: PACK_TOKEN_TYPE.ERC20,
+      tokenId: 0n, // hard-coded to `0n` for ERC20
+      totalAmount: totalRequired,
+    };
+  });
+
+  return {
+    content: result,
+    numOfRewardUnits,
+  };
+}
+
+/**
+ * @internal
+ */
+async function processErc721Rewards(options: {
+  content?: ERC721Reward[];
+  packContract: ThirdwebContract;
+  tokenOwner: string;
+}): Promise<{
+  content: AddPackContentsParams["contents"];
+  numOfRewardUnits: bigint[];
+}> {
+  const { content, packContract, tokenOwner } = options;
+  if (!content?.length) {
+    return {
+      content: [],
+      numOfRewardUnits: [],
+    };
+  }
+  const uniqueERC721Contracts = [
+    ...new Set(
+      content.map((o) => ({
+        contract: getContract({
+          address: o.contractAddress,
+          chain: packContract.chain,
+          client: packContract.client,
+        }),
+        tokenId: o.tokenId,
+      })),
+    ),
+  ];
+  const [{ isApprovedForAll }, { getApproved }] = await Promise.all([
+    import("../erc721/__generated__/IERC721A/read/isApprovedForAll.js"),
+    import("../erc721/__generated__/IERC721A/read/getApproved.js"),
+  ]);
+  const numOfRewardUnits: bigint[] = [];
+  const result = (
+    await Promise.all(
+      uniqueERC721Contracts.map(({ contract, tokenId }) => {
+        return Promise.all([
+          isApprovedForAll({
+            contract,
+            operator: packContract.address,
+            owner: tokenOwner,
+          }).catch(() => false),
+          getApproved({ contract, tokenId }).catch(() => ""),
+          contract.address,
+          tokenId,
+        ]);
+      }),
+    )
+  ).map((item) => {
+    const [_allApproved, _tokenApprove, address, tokenId] = item;
+    if (
+      !_allApproved &&
+      _tokenApprove.toLowerCase() !== packContract.address.toLowerCase()
+    ) {
+      throw new Error(
+        `TokenID: ${tokenId} from contract address ${address} is not approved to be used by this Pack contract.`,
+      );
+    }
+    numOfRewardUnits.push(1n);
+    return {
+      assetContract: address,
+      tokenType: PACK_TOKEN_TYPE.ERC721,
+      tokenId,
+      totalAmount: 1n,
+    };
+  });
+
+  return {
+    content: result,
+    numOfRewardUnits,
+  };
+}
+
+async function processErc1155Rewards(options: {
+  content?: ERC1155Reward[];
+  packContract: ThirdwebContract;
+  tokenOwner: string;
+}): Promise<{
+  content: AddPackContentsParams["contents"];
+  numOfRewardUnits: bigint[];
+}> {
+  const { content, packContract, tokenOwner } = options;
+  if (!content?.length) {
+    return {
+      content: [],
+      numOfRewardUnits: [],
+    };
+  }
+  const uniqueERC1155Contracts = [
+    ...new Set(
+      content.map((o) => ({
+        contract: getContract({
+          address: o.contractAddress,
+          chain: packContract.chain,
+          client: packContract.client,
+        }),
+        tokenId: o.tokenId,
+        quantityPerReward: o.quantityPerReward,
+        totalRewards: o.totalRewards,
+      })),
+    ),
+  ];
+  const { isApprovedForAll } = await import(
+    "../erc1155/__generated__/IERC1155/read/isApprovedForAll.js"
+  );
+  const numOfRewardUnits: bigint[] = [];
+  const result = (
+    await Promise.all(
+      uniqueERC1155Contracts.map(
+        ({ contract, tokenId, quantityPerReward, totalRewards }) => {
+          return Promise.all([
+            isApprovedForAll({
+              contract,
+              operator: packContract.address,
+              owner: tokenOwner,
+            }).catch(() => false),
+            contract.address,
+            tokenId,
+            quantityPerReward,
+            totalRewards,
+          ]);
+        },
+      ),
+    )
+  ).map((item) => {
+    const [_allApproved, address, tokenId, quantityPerReward, totalRewards] =
+      item;
+    if (!_allApproved) {
+      throw new Error(
+        `ERC1155 contract address ${address} is not approved to be used by this Pack contract.`,
+      );
+    }
+    numOfRewardUnits.push(BigInt(totalRewards));
+    return {
+      assetContract: address,
+      tokenType: PACK_TOKEN_TYPE.ERC1155,
+      tokenId,
+      totalAmount: BigInt(quantityPerReward) * BigInt(totalRewards),
+    };
+  });
+
+  return {
+    content: result,
+    numOfRewardUnits,
+  };
+}