[SDK] ZkSync deterministic deployments (#2592)

Signed-off-by: Yash <72552910+kumaryash90@users.noreply.github.com>
Co-authored-by: Jonas Daniels <jonas.daniels@outlook.com>

Author: kumaryash90

.changeset/rotten-spoons-trade.md

@@ -0,0 +1,5 @@
+---
+"@thirdweb-dev/sdk": patch
+---
+
+ZkSync deterministic deployments

legacy_packages/sdk/package.json

@@ -109,13 +109,13 @@
     "rimraf": "5.0.5",
     "typedoc-gen": "workspace:*",
     "typescript": "5.4.3",
-    "zksync-web3": "^0.14.4"
+    "zksync-ethers": "^5.6.0"
   },
   "peerDependencies": {
     "@aws-sdk/client-secrets-manager": "^3.215.0",
     "ethers": "^5",
     "ethers-aws-kms-signer": "^1.3.2",
-    "zksync-web3": "^0.14.3"
+    "zksync-ethers": "^5.6.0"
   },
   "peerDependenciesMeta": {
     "@aws-sdk/client-secrets-manager": {
@@ -124,7 +124,7 @@
     "ethers-aws-kms-signer": {
       "optional": true
     },
-    "zksync-web3": {
+    "zksync-ethers": {
       "optional": true
     }
   },

legacy_packages/sdk/src/evm/common/any-evm-utils/fetchAndCacheDeployMetadata.ts

@@ -7,6 +7,7 @@ import {
   FullPublishMetadata,
   PreDeployMetadataFetched,
 } from "../../schema/contracts/custom";
+import { CompilerOptions } from "../../types/compiler/compiler-options";
 
 type DeployAndPublishMetadata = {
   compilerMetadata: PreDeployMetadataFetched;
@@ -22,14 +23,24 @@ const deployMetadataCache =
 export async function fetchAndCacheDeployMetadata(
   publishMetadataUri: string,
   storage: ThirdwebStorage,
+  compilerOptions?: CompilerOptions,
 ): Promise<DeployMetadata> {
-  const cached = deployMetadataCache.get(publishMetadataUri);
+  const compiler = compilerOptions
+    ? `${compilerOptions.compilerType}_${
+        compilerOptions.compilerVersion || ""
+      }_${compilerOptions.evmVersion || ""}
+  `
+    : "default";
+  const cacheKey = `${compiler}_${publishMetadataUri}`;
+
+  const cached = deployMetadataCache.get(cacheKey);
   if (cached) {
     return cached;
   }
   const compilerMetadata = await fetchPreDeployMetadata(
     publishMetadataUri,
     storage,
+    compilerOptions,
   );
   let extendedMetadata;
   try {
@@ -44,6 +55,6 @@ export async function fetchAndCacheDeployMetadata(
     compilerMetadata,
     extendedMetadata,
   };
-  deployMetadataCache.put(publishMetadataUri, data);
+  deployMetadataCache.put(cacheKey, data);
   return data;
 }

legacy_packages/sdk/src/evm/common/feature-detection/fetchPreDeployMetadata.ts

@@ -5,6 +5,8 @@ import {
 import { fetchContractMetadata } from "../fetchContractMetadata";
 import { ThirdwebStorage } from "@thirdweb-dev/storage";
 import { fetchRawPredeployMetadata } from "./fetchRawPredeployMetadata";
+import { CompilerOptions } from "../../types/compiler/compiler-options";
+import invariant from "tiny-invariant";
 
 /**
  * Fetch the metadata coming from CLI, this is before deploying or releasing the contract.
@@ -15,15 +17,63 @@ import { fetchRawPredeployMetadata } from "./fetchRawPredeployMetadata";
 export async function fetchPreDeployMetadata(
   publishMetadataUri: string,
   storage: ThirdwebStorage,
+  compilerOptions?: CompilerOptions,
 ): Promise<PreDeployMetadataFetched> {
   const rawMeta = await fetchRawPredeployMetadata(publishMetadataUri, storage);
-  const deployBytecode = await (
-    await storage.download(rawMeta.bytecodeUri)
-  ).text();
-  const parsedMeta = await fetchContractMetadata(rawMeta.metadataUri, storage);
+  let bytecodeUri;
+  let metadataUri;
+
+  // TODO: Add an invariant, throw if no compilers in rawMeta in case compilerOptions are provided.
+  // Keeping it this way until all contracts are republished with new metadata.
+  if (compilerOptions && rawMeta.compilers) {
+    let metadata;
+    switch (compilerOptions.compilerType) {
+      case "solc": {
+        if (compilerOptions.compilerVersion) {
+          metadata = rawMeta.compilers.solc?.find(
+            (m) =>
+              m.compilerVersion === compilerOptions.compilerVersion &&
+              m.evmVersion === compilerOptions.evmVersion,
+          );
+        } else if (rawMeta.compilers.solc) {
+          const len = rawMeta.compilers.solc.length;
+          metadata = rawMeta.compilers.solc[len - 1];
+        }
+        break;
+      }
+      case "zksolc": {
+        if (compilerOptions.compilerVersion) {
+          metadata = rawMeta.compilers.zksolc?.find(
+            (m) =>
+              m.compilerVersion === compilerOptions.compilerVersion &&
+              m.evmVersion === compilerOptions.evmVersion,
+          );
+        } else if (rawMeta.compilers.zksolc) {
+          const len = rawMeta.compilers.zksolc.length;
+          metadata = rawMeta.compilers.zksolc[len - 1];
+        }
+        break;
+      }
+    }
+    invariant(metadata, "Compiler or EVM version not found");
+
+    bytecodeUri = metadata.bytecodeUri;
+    metadataUri = metadata.metadataUri;
+  } else {
+    bytecodeUri = rawMeta.bytecodeUri;
+    metadataUri = rawMeta.metadataUri;
+  }
+
+  const [deployBytecode, parsedMeta] = await Promise.all([
+    storage.download(bytecodeUri),
+    fetchContractMetadata(metadataUri, storage),
+  ]);
+
   return PreDeployMetadataFetchedSchema.parse({
     ...rawMeta,
     ...parsedMeta,
-    bytecode: deployBytecode,
+    bytecode: await deployBytecode.text(),
+    fetchedMetadataUri: metadataUri,
+    fetchedBytecodeUri: bytecodeUri,
   });
 }

legacy_packages/sdk/src/evm/schema/contracts/custom.ts

@@ -377,6 +377,8 @@ export const CompilerMetadataFetchedSchema = /* @__PURE__ */ (() =>
 export const PreDeployMetadataFetchedSchema = /* @__PURE__ */ (() =>
   PreDeployMetadata.merge(CompilerMetadataFetchedSchema).extend({
     bytecode: z.string(),
+    fetchedMetadataUri: z.string(),
+    fetchedBytecodeUri: z.string(),
   }))();
 
 export type PreDeployMetadataFetched = z.infer<

legacy_packages/sdk/src/evm/types/compiler/compiler-options.ts

@@ -0,0 +1,7 @@
+import { CompilerType } from "../../schema/contracts/custom";
+
+export type CompilerOptions = {
+  compilerType: CompilerType;
+  compilerVersion?: string;
+  evmVersion?: string;
+};

legacy_packages/sdk/src/evm/types/deploy/deploy-options.ts

@@ -3,10 +3,12 @@ import {
   PreDeployMetadataFetched,
 } from "../../schema/contracts/custom";
 import { DeployedContractType } from "../any-evm/deploy-data";
+import { CompilerOptions } from "../compiler/compiler-options";
 
 export type DeployOptions = {
   forceDirectDeploy?: boolean;
   saltForProxyDeploy?: string;
+  compilerOptions?: CompilerOptions;
   notifier?: (
     status: "deploying" | "deployed",
     contractType: DeployedContractType | string,

legacy_packages/sdk/src/evm/zksync/caches.ts

@@ -0,0 +1,5 @@
+// import type { DeploymentPreset } from "../../types/any-evm/deploy-data";
+
+export const caches = {
+  deploymentPresets: {} as Record<string, any>,
+};

legacy_packages/sdk/src/evm/zksync/constants.ts

@@ -0,0 +1,12 @@
+export const SINGLETON_FACTORY = "0xa51baf6a9c0ef5Db8C1898d5aDD92Bf3227d6088";
+export const KNOWN_CODES_STORAGE = "0x0000000000000000000000000000000000008004";
+export const PUBLISHED_PRIVATE_KEY = "";
+export const PUBLISHED_SIGNER = "0xf472c04EFF6F76eFe570723a55F730126281421a";
+
+export const getMarkerAbi = [
+  "function getMarker(bytes32) public view returns (uint256)",
+];
+
+export const singletonDeployAbi = [
+  "function deploy(bytes32,bytes32,bytes) external payable",
+];

legacy_packages/sdk/src/evm/zksync/constants/addresses.ts

@@ -1,5 +1,9 @@
 /* eslint-disable no-useless-computed-key */
 
+import { constants } from "ethers";
+import { ChainId } from "../../constants/chains/ChainId";
+import { NativeToken } from "../../types/currency";
+
 const AddressZero = "0x0000000000000000000000000000000000000000";
 
 /**
@@ -25,6 +29,39 @@ export const CONTRACT_ADDRESSES: Record<
   },
 };
 
+/**
+ * @public
+ */
+export const NATIVE_TOKEN_ADDRESS =
+  "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+
+/**
+ * @public
+ */
+export const NATIVE_TOKENS: Record<number, NativeToken> = /* @__PURE__ */ {
+  // eslint-disable-next-line no-useless-computed-key
+  [280]: {
+    name: "zkSync Era Testnet",
+    symbol: "ETH",
+    decimals: 18,
+    wrapped: {
+      address: "0x20b28B1e4665FFf290650586ad76E977EAb90c5D",
+      name: "Wrapped Ether",
+      symbol: "WETH",
+    },
+  },
+  [324]: {
+    name: "zkSync Era Mainnet",
+    symbol: "ETH",
+    decimals: 18,
+    wrapped: {
+      address: "0x5AEa5775959fBC2557Cc8789bC1bf90A239D9a91",
+      name: "Wrapped Ether",
+      symbol: "WETH",
+    },
+  },
+};
+
 export const blockExplorerApiMap: Record<number, string> = {
   [324]: "https://block-explorer-api.mainnet.zksync.io/api",
   [280]: "https://block-explorer-api.testnets.zksync.dev/api",
@@ -123,3 +160,23 @@ export function zkGetDefaultTrustedForwarders(
   //  it doesn’t need a forwarder
   return [];
 }
+
+/**
+ * Returns the native token for a given chain
+ * @param chainId - the chain id
+ * @public
+ */
+export function getZkNativeTokenByChainId(chainId: ChainId): NativeToken {
+  return (
+    NATIVE_TOKENS[chainId] || {
+      name: "Ether",
+      symbol: "ETH",
+      decimals: 18,
+      wrapped: {
+        address: constants.AddressZero,
+        name: "Wrapped Ether",
+        symbol: "WETH",
+      },
+    }
+  );
+}