thirdweb 5.59.1 → 5.60.0-nightly-6c26012a71d884f99dd5d8c914b3879037b36d56-20240929000339

package/src/extensions/pack/__generated__/IPackVRFDirect/write/openPackAndClaimRewards.ts

@@ -0,0 +1,177 @@
+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 "openPackAndClaimRewards" function.
+ */
+export type OpenPackAndClaimRewardsParams = WithOverrides<{
+  packId: AbiParameterToPrimitiveType<{ type: "uint256"; name: "_packId" }>;
+  amountToOpen: AbiParameterToPrimitiveType<{
+    type: "uint256";
+    name: "_amountToOpen";
+  }>;
+  callBackGasLimit: AbiParameterToPrimitiveType<{
+    type: "uint32";
+    name: "_callBackGasLimit";
+  }>;
+}>;
+
+export const FN_SELECTOR = "0xac296b3f" as const;
+const FN_INPUTS = [
+  {
+    type: "uint256",
+    name: "_packId",
+  },
+  {
+    type: "uint256",
+    name: "_amountToOpen",
+  },
+  {
+    type: "uint32",
+    name: "_callBackGasLimit",
+  },
+] as const;
+const FN_OUTPUTS = [
+  {
+    type: "uint256",
+  },
+] as const;
+
+/**
+ * Checks if the `openPackAndClaimRewards` 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 `openPackAndClaimRewards` method is supported.
+ * @extension PACK
+ * @example
+ * ```ts
+ * import { isOpenPackAndClaimRewardsSupported } from "thirdweb/extensions/pack";
+ *
+ * const supported = isOpenPackAndClaimRewardsSupported(["0x..."]);
+ * ```
+ */
+export function isOpenPackAndClaimRewardsSupported(
+  availableSelectors: string[],
+) {
+  return detectMethod({
+    availableSelectors,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "openPackAndClaimRewards" function.
+ * @param options - The options for the openPackAndClaimRewards function.
+ * @returns The encoded ABI parameters.
+ * @extension PACK
+ * @example
+ * ```ts
+ * import { encodeOpenPackAndClaimRewardsParams } from "thirdweb/extensions/pack";
+ * const result = encodeOpenPackAndClaimRewardsParams({
+ *  packId: ...,
+ *  amountToOpen: ...,
+ *  callBackGasLimit: ...,
+ * });
+ * ```
+ */
+export function encodeOpenPackAndClaimRewardsParams(
+  options: OpenPackAndClaimRewardsParams,
+) {
+  return encodeAbiParameters(FN_INPUTS, [
+    options.packId,
+    options.amountToOpen,
+    options.callBackGasLimit,
+  ]);
+}
+
+/**
+ * Encodes the "openPackAndClaimRewards" function into a Hex string with its parameters.
+ * @param options - The options for the openPackAndClaimRewards function.
+ * @returns The encoded hexadecimal string.
+ * @extension PACK
+ * @example
+ * ```ts
+ * import { encodeOpenPackAndClaimRewards } from "thirdweb/extensions/pack";
+ * const result = encodeOpenPackAndClaimRewards({
+ *  packId: ...,
+ *  amountToOpen: ...,
+ *  callBackGasLimit: ...,
+ * });
+ * ```
+ */
+export function encodeOpenPackAndClaimRewards(
+  options: OpenPackAndClaimRewardsParams,
+) {
+  // 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 +
+    encodeOpenPackAndClaimRewardsParams(options).slice(
+      2,
+    )) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Prepares a transaction to call the "openPackAndClaimRewards" function on the contract.
+ * @param options - The options for the "openPackAndClaimRewards" function.
+ * @returns A prepared transaction object.
+ * @extension PACK
+ * @example
+ * ```ts
+ * import { sendTransaction } from "thirdweb";
+ * import { openPackAndClaimRewards } from "thirdweb/extensions/pack";
+ *
+ * const transaction = openPackAndClaimRewards({
+ *  contract,
+ *  packId: ...,
+ *  amountToOpen: ...,
+ *  callBackGasLimit: ...,
+ *  overrides: {
+ *    ...
+ *  }
+ * });
+ *
+ * // Send the transaction
+ * await sendTransaction({ transaction, account });
+ * ```
+ */
+export function openPackAndClaimRewards(
+  options: BaseTransactionOptions<
+    | OpenPackAndClaimRewardsParams
+    | {
+        asyncParams: () => Promise<OpenPackAndClaimRewardsParams>;
+      }
+  >,
+) {
+  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.packId,
+        resolvedOptions.amountToOpen,
+        resolvedOptions.callBackGasLimit,
+      ] 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/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);
+  });
+});