thirdweb 5.59.1 → 5.60.0-nightly-6c26012a71d884f99dd5d8c914b3879037b36d56-20240929000339

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

package/src/extensions/permissions/permissions.test.ts

@@ -1,4 +1,5 @@
 import { beforeAll, describe, expect, it } from "vitest";
+import { TEST_CONTRACT_URI } from "~test/ipfs-uris.js";
 import { ANVIL_CHAIN } from "../../../test/src/chains.js";
 import { TEST_CLIENT } from "../../../test/src/test-clients.js";
 import {
@@ -22,6 +23,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("Permissions", () => {
       client: TEST_CLIENT,
       params: {
         name: "PermissionsErc20",
+        contractURI: TEST_CONTRACT_URI,
       },
       type: "TokenERC20",
     });
@@ -196,6 +198,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("PermissionsEnumerable", () => {
       client: TEST_CLIENT,
       params: {
         name: "PermissionsErc20",
+        contractURI: TEST_CONTRACT_URI,
       },
       type: "TokenERC20",
     });

package/src/extensions/prebuilts/__generated__/Pack/write/initialize.ts

@@ -0,0 +1,216 @@
+import type { AbiParameterToPrimitiveType } from "abitype";
+import type {
+  BaseTransactionOptions,
+  WithOverrides,
+} from "../../../../../transaction/types.js";
+import { prepareContractCall } from "../../../../../transaction/prepare-contract-call.js";
+import { encodeAbiParameters } from "../../../../../utils/abi/encodeAbiParameters.js";
+import { once } from "../../../../../utils/promise/once.js";
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+/**
+ * Represents the parameters for the "initialize" function.
+ */
+export type InitializeParams = WithOverrides<{
+  defaultAdmin: AbiParameterToPrimitiveType<{
+    type: "address";
+    name: "_defaultAdmin";
+  }>;
+  name: AbiParameterToPrimitiveType<{ type: "string"; name: "_name" }>;
+  symbol: AbiParameterToPrimitiveType<{ type: "string"; name: "_symbol" }>;
+  contractURI: AbiParameterToPrimitiveType<{
+    type: "string";
+    name: "_contractURI";
+  }>;
+  trustedForwarders: AbiParameterToPrimitiveType<{
+    type: "address[]";
+    name: "_trustedForwarders";
+  }>;
+  royaltyRecipient: AbiParameterToPrimitiveType<{
+    type: "address";
+    name: "_royaltyRecipient";
+  }>;
+  royaltyBps: AbiParameterToPrimitiveType<{
+    type: "uint256";
+    name: "_royaltyBps";
+  }>;
+}>;
+
+export const FN_SELECTOR = "0x754b8fe7" as const;
+const FN_INPUTS = [
+  {
+    type: "address",
+    name: "_defaultAdmin",
+  },
+  {
+    type: "string",
+    name: "_name",
+  },
+  {
+    type: "string",
+    name: "_symbol",
+  },
+  {
+    type: "string",
+    name: "_contractURI",
+  },
+  {
+    type: "address[]",
+    name: "_trustedForwarders",
+  },
+  {
+    type: "address",
+    name: "_royaltyRecipient",
+  },
+  {
+    type: "uint256",
+    name: "_royaltyBps",
+  },
+] as const;
+const FN_OUTPUTS = [] as const;
+
+/**
+ * Checks if the `initialize` method is supported by the given contract.
+ * @param availableSelectors An array of 4byte function selectors of the contract. You can get this in various ways, such as using "whatsabi" or if you have the ABI of the contract available you can use it to generate the selectors.
+ * @returns A boolean indicating if the `initialize` method is supported.
+ * @extension PREBUILTS
+ * @example
+ * ```ts
+ * import { isInitializeSupported } from "thirdweb/extensions/prebuilts";
+ *
+ * const supported = isInitializeSupported(["0x..."]);
+ * ```
+ */
+export function isInitializeSupported(availableSelectors: string[]) {
+  return detectMethod({
+    availableSelectors,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "initialize" function.
+ * @param options - The options for the initialize function.
+ * @returns The encoded ABI parameters.
+ * @extension PREBUILTS
+ * @example
+ * ```ts
+ * import { encodeInitializeParams } from "thirdweb/extensions/prebuilts";
+ * const result = encodeInitializeParams({
+ *  defaultAdmin: ...,
+ *  name: ...,
+ *  symbol: ...,
+ *  contractURI: ...,
+ *  trustedForwarders: ...,
+ *  royaltyRecipient: ...,
+ *  royaltyBps: ...,
+ * });
+ * ```
+ */
+export function encodeInitializeParams(options: InitializeParams) {
+  return encodeAbiParameters(FN_INPUTS, [
+    options.defaultAdmin,
+    options.name,
+    options.symbol,
+    options.contractURI,
+    options.trustedForwarders,
+    options.royaltyRecipient,
+    options.royaltyBps,
+  ]);
+}
+
+/**
+ * Encodes the "initialize" function into a Hex string with its parameters.
+ * @param options - The options for the initialize function.
+ * @returns The encoded hexadecimal string.
+ * @extension PREBUILTS
+ * @example
+ * ```ts
+ * import { encodeInitialize } from "thirdweb/extensions/prebuilts";
+ * const result = encodeInitialize({
+ *  defaultAdmin: ...,
+ *  name: ...,
+ *  symbol: ...,
+ *  contractURI: ...,
+ *  trustedForwarders: ...,
+ *  royaltyRecipient: ...,
+ *  royaltyBps: ...,
+ * });
+ * ```
+ */
+export function encodeInitialize(options: InitializeParams) {
+  // we do a "manual" concat here to avoid the overhead of the "concatHex" function
+  // we can do this because we know the specific formats of the values
+  return (FN_SELECTOR +
+    encodeInitializeParams(options).slice(
+      2,
+    )) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Prepares a transaction to call the "initialize" function on the contract.
+ * @param options - The options for the "initialize" function.
+ * @returns A prepared transaction object.
+ * @extension PREBUILTS
+ * @example
+ * ```ts
+ * import { sendTransaction } from "thirdweb";
+ * import { initialize } from "thirdweb/extensions/prebuilts";
+ *
+ * const transaction = initialize({
+ *  contract,
+ *  defaultAdmin: ...,
+ *  name: ...,
+ *  symbol: ...,
+ *  contractURI: ...,
+ *  trustedForwarders: ...,
+ *  royaltyRecipient: ...,
+ *  royaltyBps: ...,
+ *  overrides: {
+ *    ...
+ *  }
+ * });
+ *
+ * // Send the transaction
+ * await sendTransaction({ transaction, account });
+ * ```
+ */
+export function initialize(
+  options: BaseTransactionOptions<
+    | InitializeParams
+    | {
+        asyncParams: () => Promise<InitializeParams>;
+      }
+  >,
+) {
+  const asyncOptions = once(async () => {
+    return "asyncParams" in options ? await options.asyncParams() : options;
+  });
+
+  return prepareContractCall({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: async () => {
+      const resolvedOptions = await asyncOptions();
+      return [
+        resolvedOptions.defaultAdmin,
+        resolvedOptions.name,
+        resolvedOptions.symbol,
+        resolvedOptions.contractURI,
+        resolvedOptions.trustedForwarders,
+        resolvedOptions.royaltyRecipient,
+        resolvedOptions.royaltyBps,
+      ] as const;
+    },
+    value: async () => (await asyncOptions()).overrides?.value,
+    accessList: async () => (await asyncOptions()).overrides?.accessList,
+    gas: async () => (await asyncOptions()).overrides?.gas,
+    gasPrice: async () => (await asyncOptions()).overrides?.gasPrice,
+    maxFeePerGas: async () => (await asyncOptions()).overrides?.maxFeePerGas,
+    maxPriorityFeePerGas: async () =>
+      (await asyncOptions()).overrides?.maxPriorityFeePerGas,
+    nonce: async () => (await asyncOptions()).overrides?.nonce,
+    extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+  });
+}

package/src/extensions/prebuilts/deploy-erc20.test.ts

@@ -1,11 +1,13 @@
 import { describe, expect, it } from "vitest";
 import { ANVIL_CHAIN } from "../../../test/src/chains.js";
 import { TEST_CLIENT } from "../../../test/src/test-clients.js";
-import { TEST_ACCOUNT_A } from "../../../test/src/test-wallets.js";
+import { TEST_ACCOUNT_D } from "../../../test/src/test-wallets.js";
 import { getContract } from "../../contract/contract.js";
 import { name } from "../common/read/name.js";
 import { deployERC20Contract } from "./deploy-erc20.js";
 
+const account = TEST_ACCOUNT_D;
+
 // skip this test suite if there is no secret key available to test with
 // TODO: remove reliance on secret key during unit tests entirely
 describe.runIf(process.env.TW_SECRET_KEY)("deployERC20", () => {
@@ -13,7 +15,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("deployERC20", () => {
     const address = await deployERC20Contract({
       client: TEST_CLIENT,
       chain: ANVIL_CHAIN,
-      account: TEST_ACCOUNT_A,
+      account,
       type: "DropERC20",
       params: {
         name: "TokenDrop",
@@ -35,7 +37,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("deployERC20", () => {
     const address = await deployERC20Contract({
       client: TEST_CLIENT,
       chain: ANVIL_CHAIN,
-      account: TEST_ACCOUNT_A,
+      account,
       type: "TokenERC20",
       params: {
         name: "Token",