get deployed entrypoint

Author: kumaryash90

packages/thirdweb/src/tokens/constants.ts

@@ -4,3 +4,26 @@ export const DEFAULT_POOL_INITIAL_TICK = 230200;
 export const DEFAULT_DEVELOPER_REWARD_BPS = 0;
 export const DEFAULT_DEVELOPER_ADDRESS =
   "0x1Af20C6B23373350aD464700B5965CE4B0D2aD94";
+
+export const CONTRACT_FACTORY_DEPLOY_URL =
+  "ipfs://QmZ77LnDCDyzd8rqat2YDkdbKUbdNobNuoBLy1q8YfCSKq";
+export const ENTRYPOINT_DEPLOY_URL =
+  "ipfs://QmSAhuGEMtuGtBAWLB2jLacppqMPkiRtoMsy1R9Wm4PWWM";
+
+export const OWNER_ADDRESS = "0x1A472863cF21D5Aa27F417dF9140400324C48f22";
+export const MANAGER_ADDRESS = "";
+
+export const CONTRACT_DEPLOY = {
+  CREATE: 0,
+  CREATE2: 1,
+  CREATE3: 2,
+} as const;
+
+export const PROXY_DEPLOY = {
+  CLONE: 0, // Deterministic minimal proxy
+  CLONE_IMMUTABLE_ARGS: 1, // Deterministic proxy with immutable args
+  ERC1967: 2, // ERC1967 upgradeable proxy
+  ERC1967_IMMUTABLE_ARGS: 3, // ERC1967 proxy with immutable args
+  ERC1967_BEACON: 4, // ERC1967 beacon proxy
+  ERC1967_BEACON_IMMUTABLE_ARGS: 5, // ERC1967 beacon proxy with immutable args
+} as const;

packages/thirdweb/src/tokens/get-entrypoint-erc20.ts

@@ -1,8 +1,121 @@
+import type { AbiConstructor } from "abitype";
+import { getContract } from "src/contract/contract.js";
+import { getDeployedInfraContractFromMetadata } from "src/contract/deployment/utils/infra.js";
+import { computeDeployAddress } from "src/extensions/tokens/__generated__/ContractFactory/read/computeDeployAddress.js";
+import { computeProxyAddress } from "src/extensions/tokens/__generated__/ContractFactory/read/computeProxyAddress.js";
+import { encodeAbiParameters } from "src/utils/abi/encodeAbiParameters.js";
+import { normalizeFunctionParams } from "src/utils/abi/normalizeFunctionParams.js";
+import {
+  fetchBytecodeFromCompilerMetadata,
+  fetchDeployMetadata,
+} from "src/utils/any-evm/deploy-metadata.js";
+import { isContractDeployed } from "src/utils/bytecode/is-contract-deployed.js";
+import { padHex, toHex } from "src/utils/encoding/hex.js";
+import { withCache } from "src/utils/promise/withCache.js";
 import type { ClientAndChain } from "../utils/types.js";
+import {
+  CONTRACT_DEPLOY,
+  CONTRACT_FACTORY_DEPLOY_URL,
+  ENTRYPOINT_DEPLOY_URL,
+  MANAGER_ADDRESS,
+  OWNER_ADDRESS,
+  PROXY_DEPLOY,
+} from "./constants.js";
 
 export async function getDeployedEntrypointERC20(options: ClientAndChain) {
-  // TODO (1): get the create2 factory address
-  // TODO (2): get the bootstrap contract factory address from the create2 factory
-  // TODO (3): get the entrypoint contract addresses using contract factory OR predict it using the contract factory address
-  throw new Error("Asset factory deployment is not deployed yet.");
+  const cacheKey = `${options.chain.id}-${ENTRYPOINT_DEPLOY_URL}`;
+
+  return withCache(
+    async () => {
+      // 1. Get deployed contract factory
+      const contractFactory = await getDeployedContractFactory(options);
+
+      if (!contractFactory) {
+        throw new Error(
+          `Contract factory not found on chain: ${options.chain.id}`,
+        );
+      }
+
+      // 2. Fetch metadata and encode args for entrypoint implementation
+      const contractMetadata = await fetchDeployMetadata({
+        client: options.client,
+        uri: ENTRYPOINT_DEPLOY_URL,
+      });
+      const bytecode = await fetchBytecodeFromCompilerMetadata({
+        chain: options.chain,
+        client: options.client,
+        compilerMetadata: contractMetadata,
+      });
+      const constructorAbi = contractMetadata.abi.find(
+        (abi) => abi.type === "constructor",
+      ) as AbiConstructor | undefined;
+      const encodedArgs = encodeAbiParameters(
+        constructorAbi?.inputs ?? [],
+        normalizeFunctionParams(constructorAbi, {}),
+      );
+
+      // 3. Compute entrypoint implementation address
+      const entrypointImplAddress = await computeDeployAddress({
+        contract: contractFactory,
+        deployType: CONTRACT_DEPLOY.CREATE2,
+        bytecode,
+        constructorArgs: encodedArgs,
+        salt: padHex(toHex("ERC20_ENTRYPOINT:1"), { size: 32 }),
+      });
+
+      // 4. Compute entrypoint proxy address
+      const entrypointProxyAddress = await computeProxyAddress({
+        contract: contractFactory,
+        implementation: entrypointImplAddress,
+        data: "0x",
+        salt: padHex(toHex("ERC20_ENTRYPOINT_PROXY:1"), { size: 32 }),
+        deployType: PROXY_DEPLOY.ERC1967,
+      });
+      const entrypointProxy = getContract({
+        ...options,
+        address: entrypointProxyAddress,
+      });
+
+      const isDeployed = await isContractDeployed(entrypointProxy);
+
+      if (!isDeployed) {
+        throw new Error(
+          `Entrypoint is not deployed yet on chain: ${options.chain.id}`,
+        );
+      }
+
+      return entrypointProxy;
+    },
+    {
+      cacheKey,
+      cacheTime: 24 * 60 * 60 * 1000, // 1 day
+    },
+  );
+}
+
+async function getDeployedContractFactory(options: ClientAndChain) {
+  const cacheKey = `${options.chain.id}-${CONTRACT_FACTORY_DEPLOY_URL}`;
+  return withCache(
+    async () => {
+      const contractMetadata = await fetchDeployMetadata({
+        client: options.client,
+        uri: CONTRACT_FACTORY_DEPLOY_URL,
+      });
+
+      return getDeployedInfraContractFromMetadata({
+        chain: options.chain,
+        client: options.client,
+        constructorParams: {
+          owner: OWNER_ADDRESS,
+          manager: MANAGER_ADDRESS,
+        },
+        contractMetadata,
+        salt: "THIRDWEB_CONTRACT_FACTORY:1",
+      });
+    },
+    {
+      cacheKey,
+      cacheTime: 24 * 60 * 60 * 1000, // 1 day
+    },
+  );
 }