thirdweb 5.56.0-nightly-07b949dd8c07ffdeda40a5549c31ad4b09abbbf1-20240916000437 → 5.56.0-nightly-a5e605c65e360a9d3d2e553d6783e58582b50a70-20240917000331

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thirdweb",
-  "version": "5.56.0-nightly-07b949dd8c07ffdeda40a5549c31ad4b09abbbf1-20240916000437",
+  "version": "5.56.0-nightly-a5e605c65e360a9d3d2e553d6783e58582b50a70-20240917000331",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/thirdweb-dev/js.git#main"
@@ -210,7 +210,7 @@
     "@radix-ui/react-focus-scope": "1.1.0",
     "@radix-ui/react-icons": "1.3.0",
     "@radix-ui/react-tooltip": "1.1.2",
-    "@tanstack/react-query": "5.55.4",
+    "@tanstack/react-query": "5.56.2",
     "@walletconnect/ethereum-provider": "2.16.1",
     "@walletconnect/sign-client": "2.16.1",
     "abitype": "1.0.5",
@@ -220,13 +220,13 @@
     "mipd": "0.0.7",
     "node-libs-browser": "2.2.1",
     "uqr": "0.1.2",
-    "viem": "2.21.4"
+    "viem": "2.21.7"
   },
   "peerDependencies": {
     "@aws-sdk/client-lambda": "^3",
     "@aws-sdk/credential-providers": "^3",
     "@coinbase/wallet-mobile-sdk": "^1",
-    "@mobile-wallet-protocol/client": "^0.0.2",
+    "@mobile-wallet-protocol/client": "0.0.3",
     "@react-native-async-storage/async-storage": "^1 || ^2",
     "amazon-cognito-identity-js": "^6",
     "aws-amplify": "^5",
@@ -297,28 +297,28 @@
     "node": ">=18"
   },
   "devDependencies": {
-    "@aws-sdk/client-lambda": "3.592.0",
-    "@aws-sdk/credential-providers": "3.592.0",
-    "@chromatic-com/storybook": "^1.5.0",
+    "@aws-sdk/client-lambda": "3.651.1",
+    "@aws-sdk/credential-providers": "3.651.1",
+    "@chromatic-com/storybook": "2.0.2",
     "@codspeed/vitest-plugin": "3.1.1",
-    "@coinbase/wallet-mobile-sdk": "1.0.13",
+    "@coinbase/wallet-mobile-sdk": "1.1.2",
     "@mobile-wallet-protocol/client": "0.0.2",
     "@react-native-async-storage/async-storage": "1.24.0",
-    "@storybook/addon-essentials": "^8.2.9",
-    "@storybook/addon-interactions": "^8.2.9",
-    "@storybook/addon-links": "^8.2.9",
-    "@storybook/addon-onboarding": "^8.2.9",
-    "@storybook/blocks": "^8.2.9",
-    "@storybook/react": "^8.2.9",
-    "@storybook/react-vite": "^8.2.9",
-    "@storybook/test": "^8.2.9",
+    "@storybook/addon-essentials": "8.3.0",
+    "@storybook/addon-interactions": "8.3.0",
+    "@storybook/addon-links": "8.3.0",
+    "@storybook/addon-onboarding": "8.3.0",
+    "@storybook/blocks": "8.3.0",
+    "@storybook/react": "8.3.0",
+    "@storybook/react-vite": "8.3.0",
+    "@storybook/test": "8.3.0",
     "@testing-library/jest-dom": "^6.4.7",
     "@testing-library/react": "^16.0.0",
     "@testing-library/user-event": "^14.5.2",
     "@types/cross-spawn": "^6.0.6",
     "@types/react": "^18.3.5",
     "@vitejs/plugin-react": "^4.3.1",
-    "@vitest/ui": "2.0.5",
+    "@vitest/ui": "2.1.1",
     "amazon-cognito-identity-js": "6.3.12",
     "aws-amplify": "5.3.19",
     "cross-spawn": "7.0.3",
@@ -327,15 +327,15 @@
     "expo-linking": "6.3.1",
     "expo-web-browser": "13.0.3",
     "happy-dom": "^14.12.0",
-    "msw": "2.4.4",
-    "react-native": "0.75.2",
+    "msw": "2.4.7",
+    "react-native": "0.75.3",
     "react-native-aes-gcm-crypto": "0.2.2",
     "react-native-passkey": "3.0.0-beta2",
-    "react-native-quick-crypto": "0.7.0-rc.6",
-    "react-native-svg": "15.3.0",
-    "storybook": "^8.2.9",
+    "react-native-quick-crypto": "0.7.4",
+    "react-native-svg": "15.6.0",
+    "storybook": "8.3.0",
     "typescript": "5.6.2",
-    "vite": "5.4.3"
+    "vite": "5.4.5"
   },
   "scripts": {
     "bench:compare": "bun run ./benchmarks/run.ts",

package/src/contract/deployment/publisher.ts

@@ -12,7 +12,8 @@ import { withCache } from "../../utils/promise/withCache.js";
 
 import { type ThirdwebContract, getContract } from "../contract.js";
 
-const CONTRACT_PUBLISHER_ADDRESS = "0xf5b896Ddb5146D5dA77efF4efBb3Eae36E300808"; // Polygon only
+export const CONTRACT_PUBLISHER_ADDRESS =
+  "0xf5b896Ddb5146D5dA77efF4efBb3Eae36E300808"; // Polygon only
 export const THIRDWEB_DEPLOYER = "0xdd99b75f095d0c4d5112aCe938e4e6ed962fb024";
 
 /**

package/src/exports/extensions/thirdweb.ts

@@ -35,10 +35,6 @@ export {
 } from "../../extensions/thirdweb/__generated__/IContractPublisher/read/getPublishedContractVersions.js";
 
 // Write
-export {
-  publishContract,
-  type PublishContractParams,
-} from "../../extensions/thirdweb/__generated__/IContractPublisher/write/publishContract.js";
 export {
   setPublisherProfileUri,
   type SetPublisherProfileUriParams,
@@ -48,6 +44,12 @@ export {
   type UnpublishContractParams,
 } from "../../extensions/thirdweb/__generated__/IContractPublisher/write/unpublishContract.js";
 
+export {
+  publishContract,
+  type PublishContractParams,
+  getContractPublisher,
+} from "../../extensions/thirdweb/write/publish.js";
+
 // --------------------------------------------------------
 // Multichain Registry
 // --------------------------------------------------------

package/src/exports/modules.ts

@@ -121,6 +121,7 @@ export {
   rolesOf,
   type RolesOfParams,
 } from "../extensions/modules/__generated__/OwnableRoles/read/rolesOf.js";
+export { checkModulesCompatibility } from "../extensions/modules/common/checkModulesCompatibility.js";
 
 /**
  * Write
@@ -158,7 +159,10 @@ export {
   isUninstallModuleSupported,
   type UninstallModuleParams,
 } from "../extensions/modules/__generated__/IModularCore/write/uninstallModule.js";
-export { getModuleConfig } from "../extensions/modules/__generated__/IModule/read/getModuleConfig.js";
+export {
+  getModuleConfig,
+  isGetModuleConfigSupported,
+} from "../extensions/modules/__generated__/IModule/read/getModuleConfig.js";
 export {
   installPublishedModule,
   type InstallPublishedModuleOptions,

package/src/extensions/erc721/lazyMinting/write/createAndReveal.test.ts

@@ -29,7 +29,7 @@ const realNFTs = [
   },
 ];
 
-describe("createAndReveal", () => {
+describe.runIf(process.env.TW_SECRET_KEY)("createAndReveal", () => {
   let contract: ThirdwebContract;
   beforeAll(async () => {
     const address = await deployERC721Contract({

package/src/extensions/modules/MintableERC1155/mintableERC1155.test.ts

@@ -21,7 +21,7 @@ import { getInstalledModules } from "../__generated__/IModularCore/read/getInsta
 import { grantMinterRole } from "../common/grantMinterRole.js";
 import * as MintableERC1155 from "./index.js";
 
-describe("ModularTokenERC1155", () => {
+describe.runIf(process.env.TW_SECRET_KEY)("ModularTokenERC1155", () => {
   let contract: ThirdwebContract;
   beforeAll(async () => {
     const address = await deployModularContract({

package/src/extensions/modules/MintableERC20/mintableERC20.test.ts

@@ -16,7 +16,7 @@ import { getInstalledModules } from "../__generated__/IModularCore/read/getInsta
 import { grantMinterRole } from "../common/grantMinterRole.js";
 import * as MintableERC20 from "./index.js";
 
-describe("ModularTokenERC20", () => {
+describe.runIf(process.env.TW_SECRET_KEY)("ModularTokenERC20", () => {
   let contract: ThirdwebContract;
   beforeAll(async () => {
     const address = await deployModularContract({

package/src/extensions/modules/MintableERC721/mintableERC721.test.ts

@@ -20,7 +20,7 @@ import { getInstalledModules } from "../__generated__/IModularCore/read/getInsta
 import { grantMinterRole } from "../common/grantMinterRole.js";
 import * as MintableERC721 from "./index.js";
 
-describe("ModularTokenERC721", () => {
+describe.runIf(process.env.TW_SECRET_KEY)("ModularTokenERC721", () => {
   let contract: ThirdwebContract;
   beforeAll(async () => {
     const address = await deployModularContract({

package/src/extensions/modules/common/checkModulesCompatibility.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+import { CLAIMABLE_ERC20_MODULE_BYTECODE } from "../../../../test/src/bytecode/claimable-erc20.js";
+import { CLAIMABLE_ERC721_BYTECODE } from "../../../../test/src/bytecode/claimable-erc721.js";
+import { ERC20_CORE_BYTECODE } from "../../../../test/src/bytecode/erc20core.js";
+import { MINTABLE_ERC20_BYTECODE } from "../../../../test/src/bytecode/mintable-erc20.js";
+import { ANVIL_CHAIN } from "../../../../test/src/chains.js";
+import { TEST_CLIENT } from "../../../../test/src/test-clients.js";
+import { checkModulesCompatibility } from "./checkModulesCompatibility.js";
+
+describe("compatibleModules", () => {
+  it("should return true for compatible modules", async () => {
+    const result = await checkModulesCompatibility({
+      coreBytecode: ERC20_CORE_BYTECODE,
+      moduleBytecodes: [CLAIMABLE_ERC20_MODULE_BYTECODE],
+      chain: ANVIL_CHAIN,
+      client: TEST_CLIENT,
+    });
+
+    expect(result).toBe(true);
+  });
+
+  it("should return false for incompatible modules", async () => {
+    const result = await checkModulesCompatibility({
+      coreBytecode: ERC20_CORE_BYTECODE,
+      moduleBytecodes: [CLAIMABLE_ERC721_BYTECODE],
+      chain: ANVIL_CHAIN,
+      client: TEST_CLIENT,
+    });
+
+    expect(result).toBe(false);
+  });
+
+  it("should return false for overlapping modules", async () => {
+    const result = await checkModulesCompatibility({
+      coreBytecode: ERC20_CORE_BYTECODE,
+      moduleBytecodes: [
+        CLAIMABLE_ERC20_MODULE_BYTECODE,
+        MINTABLE_ERC20_BYTECODE,
+      ],
+      chain: ANVIL_CHAIN,
+      client: TEST_CLIENT,
+    });
+
+    expect(result).toBe(false);
+  });
+});

package/src/extensions/modules/common/checkModulesCompatibility.ts

@@ -0,0 +1,123 @@
+import {} from "abitype";
+import type { Chain } from "../../../chains/types.js";
+import type { ThirdwebClient } from "../../../client/client.js";
+import { eth_call } from "../../../rpc/actions/eth_call.js";
+import { getRpcClient } from "../../../rpc/rpc.js";
+import { hasDuplicates } from "../../../utils/arrays.js";
+import { ensureBytecodePrefix } from "../../../utils/bytecode/prefix.js";
+import type { Hex } from "../../../utils/encoding/hex.js";
+import {
+  decodeSupportsInterfaceResult,
+  encodeSupportsInterface,
+} from "../../erc165/__generated__/IERC165/read/supportsInterface.js";
+import {
+  decodeGetSupportedCallbackFunctionsResult,
+  FN_SELECTOR as getSupportedCallbackFunctionsSelector,
+} from "../__generated__/IModularCore/read/getSupportedCallbackFunctions.js";
+import {
+  decodeGetModuleConfigResult,
+  FN_SELECTOR as getModuleConfigSelector,
+} from "../__generated__/IModule/read/getModuleConfig.js";
+
+export async function checkModulesCompatibility(options: {
+  coreBytecode: string;
+  moduleBytecodes: string[];
+  chain: Chain;
+  client: ThirdwebClient;
+}): Promise<boolean> {
+  const addr = "0x0000000000000000000000000000000000000124"; // arbitrary address
+  let _coreBytecode = ensureBytecodePrefix(options.coreBytecode);
+  if (!_coreBytecode.startsWith("0x6080604052")) {
+    const index = _coreBytecode.indexOf("6080604052");
+    _coreBytecode = `0x${_coreBytecode.substring(index)}`;
+  } else if (_coreBytecode.lastIndexOf("6080604052") > 0) {
+    const index = _coreBytecode.lastIndexOf("6080604052");
+    _coreBytecode = `0x${_coreBytecode.substring(index)}`;
+  }
+  const rpcClient = getRpcClient({
+    client: options.client,
+    chain: options.chain,
+  });
+
+  // get the core's supported callback functions
+  const coreCallResult = await eth_call(rpcClient, {
+    data: getSupportedCallbackFunctionsSelector,
+    to: addr,
+    stateOverrides: {
+      [addr]: {
+        code: _coreBytecode,
+      },
+    },
+  });
+
+  const decodedCallResult =
+    decodeGetSupportedCallbackFunctionsResult(coreCallResult);
+  const coreCallbackSelectors = decodedCallResult.flat().map((c) => c.selector);
+
+  // get the module config for each module
+  const modules = await Promise.all(
+    options.moduleBytecodes.map(async (b: string) => {
+      // TODO: Upload deployed bytecode on publish metadata
+      let moduleBytecode = ensureBytecodePrefix(b);
+      if (!moduleBytecode.startsWith("0x6080604052")) {
+        const index = moduleBytecode.indexOf("6080604052");
+        moduleBytecode = `0x${moduleBytecode.substring(index)}`;
+      } else if (moduleBytecode.lastIndexOf("6080604052") > 0) {
+        const index = moduleBytecode.lastIndexOf("6080604052");
+        moduleBytecode = `0x${moduleBytecode.substring(index)}`;
+      }
+
+      const callResult = await eth_call(rpcClient, {
+        data: getModuleConfigSelector,
+        to: addr,
+        stateOverrides: {
+          [addr]: {
+            code: moduleBytecode,
+          },
+        },
+      });
+      return decodeGetModuleConfigResult(callResult);
+    }),
+  );
+
+  // check if callback selectors are supported
+  for (const module of modules) {
+    for (const callback of module.callbackFunctions) {
+      if (!coreCallbackSelectors.includes(callback.selector)) {
+        return false;
+      }
+    }
+  }
+
+  // check if the core contract supports required interfaces by modules above
+  const requiredInterfaces = modules.flatMap((m) => m.requiredInterfaces);
+  if (requiredInterfaces.length > 0) {
+    const supportsInterfaceResult = await Promise.all(
+      requiredInterfaces.map(async (r) => {
+        const callResult = await eth_call(rpcClient, {
+          data: encodeSupportsInterface({
+            interfaceId: r,
+          }),
+          to: addr,
+          stateOverrides: {
+            [addr]: {
+              code: _coreBytecode,
+            },
+          },
+        });
+        return decodeSupportsInterfaceResult(callResult);
+      }),
+    );
+
+    if (supportsInterfaceResult.flat().some((element) => element === false)) {
+      return false;
+    }
+  }
+  return !hasDuplicates(
+    [
+      ...modules.flatMap((m) => m.callbackFunctions.map((c) => c.selector)),
+      ...modules.flatMap((m) => m.fallbackFunctions.map((f) => f.selector)),
+    ],
+    (a: Hex | undefined, b: Hex | undefined): boolean => a === b,
+  );
+}

package/src/extensions/thirdweb/write/publish.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, it } from "vitest";
+import { FORKED_POLYGON_CHAIN } from "../../../../test/src/chains.js";
+import { TEST_CLIENT } from "../../../../test/src/test-clients.js";
+import { TEST_ACCOUNT_D } from "../../../../test/src/test-wallets.js";
+import { getContract } from "../../../contract/contract.js";
+import { CONTRACT_PUBLISHER_ADDRESS } from "../../../contract/deployment/publisher.js";
+import { parseEventLogs } from "../../../event/actions/parse-logs.js";
+import { download } from "../../../storage/download.js";
+import { sendAndConfirmTransaction } from "../../../transaction/actions/send-and-confirm-transaction.js";
+import { fetchDeployMetadata } from "../../../utils/any-evm/deploy-metadata.js";
+import { contractPublishedEvent } from "../__generated__/IContractPublisher/events/ContractPublished.js";
+import { getAllPublishedContracts } from "../__generated__/IContractPublisher/read/getAllPublishedContracts.js";
+import { getPublishedContractVersions } from "../__generated__/IContractPublisher/read/getPublishedContractVersions.js";
+import { publishContract } from "./publish.js";
+
+describe.runIf(process.env.TW_SECRET_KEY)("publishContract", () => {
+  it("should publish a contract successfully", async () => {
+    const publisherContract = getContract({
+      client: TEST_CLIENT,
+      chain: FORKED_POLYGON_CHAIN,
+      address: CONTRACT_PUBLISHER_ADDRESS,
+    });
+
+    let publishedContracts = await getAllPublishedContracts({
+      contract: publisherContract,
+      publisher: TEST_ACCOUNT_D.address,
+    });
+
+    expect(publishedContracts.length).toBe(0);
+
+    const catAttackDeployMetadata = await fetchDeployMetadata({
+      client: TEST_CLIENT,
+      uri: "ipfs://QmWcAMvBy49WRrzZeK4EQeVnkdmyb5H4STz4gUQwnt1kzC",
+    });
+
+    const tx = publishContract({
+      contract: publisherContract,
+      account: TEST_ACCOUNT_D,
+      metadata: {
+        ...catAttackDeployMetadata,
+        version: "0.0.1",
+        description: "Cat Attack NFT",
+        changelog: "Initial release",
+      },
+    });
+    const result = await sendAndConfirmTransaction({
+      transaction: tx,
+      account: TEST_ACCOUNT_D,
+    });
+    expect(result.transactionHash.length).toBeGreaterThan(0);
+    const logs = parseEventLogs({
+      events: [contractPublishedEvent()],
+      logs: result.logs,
+    });
+    expect(logs?.[0]?.args.publishedContract.contractId).toBe("CatAttackNFT");
+    expect(logs?.[0]?.args.publishedContract.publishMetadataUri).toBeDefined();
+    const rawMeta = await download({
+      client: TEST_CLIENT,
+      uri: logs?.[0]?.args.publishedContract.publishMetadataUri ?? "",
+    }).then((r) => r.json());
+    expect(rawMeta).toMatchInlineSnapshot(`
+      {
+        "bytecodeUri": "ipfs://QmVyB9qAs7XdZYNGPcNbff43BX1tyZFJkqdfp1eXiNS8AG/0",
+        "changelog": "Initial release",
+        "compilers": {
+          "solc": [
+            {
+              "bytecodeUri": "ipfs://QmVyB9qAs7XdZYNGPcNbff43BX1tyZFJkqdfp1eXiNS8AG/0",
+              "compilerVersion": "",
+              "evmVersion": "",
+              "metadataUri": "ipfs://Qmd2Ef29NzCjomqYXZbWa8ZdF1AESDAS1HDAonmAnTgHPs",
+            },
+          ],
+        },
+        "description": "Cat Attack NFT",
+        "metadataUri": "ipfs://Qmd2Ef29NzCjomqYXZbWa8ZdF1AESDAS1HDAonmAnTgHPs",
+        "name": "CatAttackNFT",
+        "publisher": "0x90F79bf6EB2c4f870365E785982E1f101E93b906",
+        "routerType": "none",
+        "version": "0.0.1",
+      }
+    `);
+    const publishedData = await fetchDeployMetadata({
+      client: TEST_CLIENT,
+      uri: logs?.[0]?.args.publishedContract.publishMetadataUri ?? "",
+    });
+    expect(publishedData.abi).toBeDefined();
+    expect(publishedData.bytecode).toBeDefined();
+    expect(publishedData.version).toBe("0.0.1");
+    expect(publishedData.changelog).toBe("Initial release");
+    expect(publishedData.name).toBe("CatAttackNFT");
+    expect(publishedData.description).toBe("Cat Attack NFT");
+    expect(publishedData.publisher).toBe(TEST_ACCOUNT_D.address);
+    expect(publishedData.routerType).toBe("none");
+
+    publishedContracts = await getAllPublishedContracts({
+      contract: publisherContract,
+      publisher: TEST_ACCOUNT_D.address,
+    });
+
+    expect(publishedContracts.length).toBe(1);
+
+    expect(
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_D,
+        transaction: publishContract({
+          contract: publisherContract,
+          account: TEST_ACCOUNT_D,
+          previousMetadata: publishedData,
+          metadata: {
+            ...publishedData,
+            version: "0.0.1",
+            changelog: "Initial release 2",
+          },
+        }),
+      }),
+    ).rejects.toThrow("Version 0.0.1 is not greater than 0.0.1");
+
+    const tx2 = publishContract({
+      contract: publisherContract,
+      account: TEST_ACCOUNT_D,
+      previousMetadata: publishedData,
+      metadata: {
+        ...publishedData,
+        version: "0.0.2",
+        changelog: "Initial release 2",
+      },
+    });
+    const result2 = await sendAndConfirmTransaction({
+      transaction: tx2,
+      account: TEST_ACCOUNT_D,
+    });
+
+    expect(result2.transactionHash.length).toBeGreaterThan(0);
+    const logs2 = parseEventLogs({
+      events: [contractPublishedEvent()],
+      logs: result2.logs,
+    });
+    expect(logs2?.[0]?.args.publishedContract.contractId).toBe("CatAttackNFT");
+    expect(logs2?.[0]?.args.publishedContract.publishMetadataUri).toBeDefined();
+    const publishedData2 = await fetchDeployMetadata({
+      client: TEST_CLIENT,
+      uri: logs2?.[0]?.args.publishedContract.publishMetadataUri ?? "",
+    });
+    expect(publishedData2.version).toBe("0.0.2");
+
+    publishedContracts = await getAllPublishedContracts({
+      contract: publisherContract,
+      publisher: TEST_ACCOUNT_D.address,
+    });
+
+    expect(publishedContracts.length).toBe(1);
+
+    const versions = await getPublishedContractVersions({
+      contract: publisherContract,
+      contractId: "CatAttackNFT",
+      publisher: TEST_ACCOUNT_D.address,
+    });
+
+    expect(versions.length).toEqual(2);
+  }, 120000);
+});

package/src/extensions/thirdweb/write/publish.ts

@@ -0,0 +1,131 @@
+import type { Abi } from "abitype";
+import { encodePacked, keccak256, toFunctionSelector } from "viem/utils";
+import { polygon } from "../../../chains/chain-definitions/polygon.js";
+import type { ThirdwebClient } from "../../../client/client.js";
+import { ZERO_ADDRESS } from "../../../constants/addresses.js";
+import { getContract } from "../../../contract/contract.js";
+import { CONTRACT_PUBLISHER_ADDRESS } from "../../../contract/deployment/publisher.js";
+import { download } from "../../../storage/download.js";
+import { upload } from "../../../storage/upload.js";
+import type { BaseTransactionOptions } from "../../../transaction/types.js";
+import type {
+  ExtendedMetadata,
+  FetchDeployMetadataResult,
+} from "../../../utils/any-evm/deploy-metadata.js";
+import { ensureBytecodePrefix } from "../../../utils/bytecode/prefix.js";
+import { isIncrementalVersion } from "../../../utils/semver.js";
+import type { Account } from "../../../wallets/interfaces/wallet.js";
+import { isGetInstalledModulesSupported } from "../../modules/__generated__/IModularCore/read/getInstalledModules.js";
+import { publishContract as generatedPublishContract } from "../__generated__/IContractPublisher/write/publishContract.js";
+
+export type PublishContractParams = {
+  account: Account;
+  metadata: FetchDeployMetadataResult & {
+    version: string;
+  };
+  previousMetadata?: FetchDeployMetadataResult;
+};
+
+/**
+ * Publish a contract to the contract publisher.
+ *
+ * @param options - The options for publishing the contract.
+ * @returns The transaction to publish the contract.
+ * @example
+ * ```ts
+ * const tx = publishContract({
+ *   contract,
+ *   account,
+ *   metadata,
+ * });
+ * ```
+ * @extension thirdweb
+ */
+export function publishContract(
+  options: BaseTransactionOptions<PublishContractParams>,
+) {
+  return generatedPublishContract({
+    contract: options.contract,
+    async asyncParams() {
+      const currentVersion = options.previousMetadata?.version;
+      // check if the version is greater than the current version
+      if (
+        currentVersion &&
+        !isIncrementalVersion(currentVersion, options.metadata.version)
+      ) {
+        throw Error(
+          `Version ${options.metadata.version} is not greater than ${currentVersion}`,
+        );
+      }
+      // hash the bytecode
+      const bytecode = await download({
+        client: options.contract.client,
+        uri: options.metadata.bytecodeUri,
+      }).then((r) => r.text());
+      const bytecodeHash = keccak256(
+        encodePacked(["bytes"], [ensureBytecodePrefix(bytecode)]),
+      );
+
+      const abi = options.metadata.abi;
+      const routerType = getRouterType(abi);
+      // not spreading here, we don't want to re-upload the fetched data like bytecode
+      const newMetadata: ExtendedMetadata = {
+        bytecodeUri: options.metadata.bytecodeUri,
+        metadataUri: options.metadata.metadataUri,
+        name: options.metadata.name,
+        version: options.metadata.version,
+        audit: options.metadata.audit,
+        changelog: options.metadata.changelog,
+        compositeAbi: options.metadata.compositeAbi,
+        constructorParams: options.metadata.constructorParams,
+        defaultExtensions: options.metadata.defaultExtensions,
+        defaultModules: options.metadata.defaultModules,
+        deployType: options.metadata.deployType,
+        description: options.metadata.description,
+        displayName: options.metadata.displayName,
+        factoryDeploymentData: options.metadata.factoryDeploymentData,
+        isDeployableViaFactory: options.metadata.isDeployableViaFactory,
+        isDeployableViaProxy: options.metadata.isDeployableViaProxy,
+        logo: options.metadata.logo,
+        networksForDeployment: options.metadata.networksForDeployment,
+        readme: options.metadata.readme,
+        tags: options.metadata.tags,
+        compilers: options.metadata.compilers,
+        publisher: options.account.address,
+        routerType,
+      };
+
+      // upload the new metadata
+      const newMetadataUri = await upload({
+        client: options.contract.client,
+        files: [newMetadata],
+      });
+
+      return {
+        publisher: options.account.address,
+        contractId: options.metadata.name,
+        publishMetadataUri: newMetadataUri,
+        compilerMetadataUri: options.metadata.metadataUri,
+        bytecodeHash,
+        implementation: ZERO_ADDRESS,
+      };
+    },
+  });
+}
+
+export function getContractPublisher(client: ThirdwebClient) {
+  return getContract({
+    client,
+    chain: polygon,
+    address: CONTRACT_PUBLISHER_ADDRESS,
+  });
+}
+
+function getRouterType(abi: Abi) {
+  const fnSelectors = abi
+    .filter((f) => f.type === "function")
+    .map((f) => toFunctionSelector(f));
+  const isModule = isGetInstalledModulesSupported(fnSelectors);
+  // TODO add dynamic detection
+  return isModule ? "modular" : "none";
+}