test

Author: kumaryash90

packages/thirdweb/src/extensions/prebuilts/deploy-published.ts

@@ -19,6 +19,7 @@ import type { FetchDeployMetadataResult } from "../../utils/any-evm/deploy-metad
 import type { Hex } from "../../utils/encoding/hex.js";
 import type { Account } from "../../wallets/interfaces/wallet.js";
 import { getAllDefaultConstructorParamsForImplementation } from "./get-required-transactions.js";
+import { processRefDeployments, type ImplementationConstructorParam } from "./process-ref-deployments.js";
 
 /**
  * @extension DEPLOY
@@ -129,187 +130,6 @@ export type DeployContractfromDeployMetadataOptions = {
   salt?: string;
 };
 
-type DynamicParams = {
-  type: "address" | "address[]" | "bytes" | "bytes[]";
-  refContracts: {
-    publisherAddress: string;
-    version: string;
-    contractId: string;
-    salt?: string;
-  }[];
-  decodedBytes: Array<
-    Array<{
-      type: string;
-      defaultValue?: string;
-      dynamicValue?: DynamicParams;
-    }>
-  >;
-}
-
-type ImplementationConstructorParam = {
-  defaultValue?: string;
-  dynamicValue?: DynamicParams;
-}
-
-type ProcessRefDeploymentsOptions = {
-  client: ThirdwebClient;
-  chain: Chain;
-  account: Account;
-  paramValue: string | ImplementationConstructorParam;
-};
-
-async function processRefDeployments(
-  options: ProcessRefDeploymentsOptions,
-): Promise<string> {
-  const { client, account, chain, paramValue } = options;
-
-  try {
-    if (typeof paramValue === "object") {
-      if (
-        "defaultValue" in paramValue &&
-        paramValue.defaultValue &&
-        paramValue.defaultValue.length > 0
-      ) {
-        return paramValue.defaultValue;
-      }
-
-      if ("dynamicValue" in paramValue && paramValue.dynamicValue) {
-        const dynamicValue = paramValue.dynamicValue;
-        const contracts = dynamicValue.refContracts;
-
-        if (dynamicValue.type === "address") {
-          const salt =
-            contracts[0]?.salt && contracts[0]?.salt.length > 0
-              ? contracts[0]?.salt
-              : undefined;
-
-          const addr = await deployPublishedContract({
-            client,
-            chain,
-            account,
-            contractId: contracts[0]?.contractId as string,
-            publisher: contracts[0]?.publisherAddress,
-            version: contracts[0]?.version,
-            salt,
-          });
-
-          return addr;
-        }
-
-        if (dynamicValue.type === "address[]") {
-          const addressArray = [];
-
-          for (const c of contracts) {
-            const salt = c?.salt && c?.salt.length > 0 ? c?.salt : undefined;
-
-            addressArray.push(
-              await deployPublishedContract({
-                client,
-                chain,
-                account,
-                contractId: c.contractId,
-                publisher: c.publisherAddress,
-                version: c.version,
-                salt,
-              }),
-            );
-          }
-
-          return JSON.stringify(addressArray);
-        }
-
-        if (dynamicValue.type === "bytes") {
-          const decodedBytes = dynamicValue.decodedBytes[0];
-
-          if (decodedBytes) {
-            const types = [];
-            const values = [];
-            for (const v of decodedBytes) {
-              types.push(v.type);
-
-              if (v.defaultValue) {
-                values.push(v.defaultValue);
-              }
-
-              if (v.dynamicValue) {
-                values.push(
-                  await processRefDeployments({
-                    client,
-                    account,
-                    chain,
-                    paramValue: v,
-                  }),
-                );
-              }
-            }
-
-            return encodeAbiParameters(
-              types.map((t) => {
-                return { name: "", type: t };
-              }),
-              values,
-            );
-          }
-        }
-
-        if (dynamicValue.type === "bytes[]") {
-          const bytesArray = [];
-          const decodedBytesArray = dynamicValue.decodedBytes;
-
-          for (const a of decodedBytesArray) {
-            const decodedBytes = a;
-
-            if (decodedBytes) {
-              const types = [];
-              const values = [];
-              for (const v of decodedBytes) {
-                types.push(v.type);
-
-                if (v.defaultValue) {
-                  values.push(v.defaultValue);
-                }
-
-                if (v.dynamicValue) {
-                  values.push(
-                    await processRefDeployments({
-                      client,
-                      account,
-                      chain,
-                      paramValue: v,
-                    }),
-                  );
-                }
-              }
-
-              bytesArray.push(
-                encodeAbiParameters(
-                  types.map((t) => {
-                    return { name: "", type: t };
-                  }),
-                  values,
-                ),
-              );
-            }
-          }
-
-          return JSON.stringify(bytesArray);
-        }
-      }
-    }
-    // biome-ignore lint/suspicious/noExplicitAny: catch multiple errors
-  } catch (e: any) {
-    const err = "error" in e ? e.error?.message : e?.message;
-
-    if (err.toString().includes("Contract already deployed")) {
-      return paramValue as string;
-    }
-
-    throw e;
-  }
-
-  return paramValue as string;
-}
-
 /**
  * @internal
  */

packages/thirdweb/src/extensions/prebuilts/process-ref-deployments.test.ts

@@ -0,0 +1,101 @@
+import { beforeAll, 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 { getContract } from "../../contract/contract.js";
+import { getInstalledModules } from "../modules/__generated__/IModularCore/read/getInstalledModules.js";
+import {
+  deployPublishedContract,
+} from "./deploy-published.js";
+import { readContract } from "../../transaction/read-contract.js";
+
+describe.runIf(process.env.TW_SECRET_KEY)(
+  "deployref",
+  {
+    timeout: 120000,
+  },
+  () => {
+    let multisigAddress: string;
+    let mintfeeManagerModuleAddress: string;
+    let mintfeeManagerCoreAddress: string;
+    let claimableModuleAddress: string;
+
+    beforeAll(async () => {
+      multisigAddress = await deployPublishedContract({
+        client: TEST_CLIENT,
+        chain: ANVIL_CHAIN,
+        account: TEST_ACCOUNT_A,
+        contractId: "MultiSig",
+        version: "0.0.3",
+        salt: "tw",
+        publisher: "0x6453a486d52e0EB6E79Ec4491038E2522a926936",
+      });
+      mintfeeManagerModuleAddress = await deployPublishedContract({
+        client: TEST_CLIENT,
+        chain: ANVIL_CHAIN,
+        account: TEST_ACCOUNT_A,
+        contractId: "MintFeeManagerModule",
+        version: "0.0.1",
+        salt: "tw",
+        publisher: "0x6453a486d52e0EB6E79Ec4491038E2522a926936",
+      });
+      mintfeeManagerCoreAddress = await deployPublishedContract({
+        client: TEST_CLIENT,
+        chain: ANVIL_CHAIN,
+        account: TEST_ACCOUNT_A,
+        contractId: "MintFeeManagerCore",
+        version: "0.0.23",
+        salt: "tw",
+        publisher: "0x6453a486d52e0EB6E79Ec4491038E2522a926936",
+      });
+      claimableModuleAddress = await deployPublishedContract({
+        client: TEST_CLIENT,
+        chain: ANVIL_CHAIN,
+        account: TEST_ACCOUNT_A,
+        contractId: "ClaimableERC721",
+        version: "0.0.12",
+        salt: "tw",
+        publisher: "0x6453a486d52e0EB6E79Ec4491038E2522a926936",
+      });
+    }, 120000);
+
+    it("should set ref contract dependencies", async () => {
+        const claimableModule = getContract({
+            client: TEST_CLIENT,
+            chain: ANVIL_CHAIN,
+            address: claimableModuleAddress,
+        });
+        const fetchedMintFeeManagerAddress = await readContract({
+            contract: claimableModule,
+            method: "function mintFeeManager() returns (address)",
+        });
+        expect(fetchedMintFeeManagerAddress.toLowerCase()).to.eq(mintfeeManagerCoreAddress);
+
+        const mintFeeManager = getContract({
+            client: TEST_CLIENT,
+            chain: ANVIL_CHAIN,
+            address: mintfeeManagerCoreAddress,
+        });
+        const owner = await readContract({
+            contract: mintFeeManager,
+            method: "function owner() returns (address)",
+        });
+        const modules = await getInstalledModules({
+            contract: mintFeeManager,
+        });
+        const feeRecipient = await readContract({
+            contract: mintFeeManager,
+            method: "function getfeeRecipient() returns (address)",
+        });
+        const fee = await readContract({
+            contract: mintFeeManager,
+            method: "function getDefaultMintFee() returns (uint256)",
+        });
+        expect(owner.toLowerCase()).to.eq(multisigAddress);
+        expect(modules.length).to.eq(1);
+        expect(modules[0]?.implementation.toLowerCase()).to.eq(mintfeeManagerModuleAddress);
+        expect(feeRecipient.toLowerCase()).to.eq("0x000000000000000000000000000000000000dead");
+        expect(fee).to.eq(5n);
+    });
+  },
+);