viem 0.0.0-main.20240324T200829 → 0.0.0-main.20240324T211636

package/chains/zksync/utils/abi/encodeDeployData.ts

@@ -0,0 +1,120 @@
+import type { Abi } from 'abitype'
+
+import { zeroHash } from '../../../../constants/bytes.js'
+import {
+  AbiConstructorNotFoundError,
+  AbiConstructorParamsNotFoundError,
+} from '../../../../errors/abi.js'
+import type { ContractConstructorArgs } from '../../../../types/contract.js'
+import type { Hash } from '../../../../types/misc.js'
+import type { Hex } from '../../../../types/misc.js'
+import { encodeAbiParameters } from '../../../../utils/abi/encodeAbiParameters.js'
+import {
+  type EncodeDeployDataParameters as EncodeDeployDataParameters_,
+  type EncodeDeployDataReturnType,
+} from '../../../../utils/abi/encodeDeployData.js'
+import { encodeFunctionData } from '../../../../utils/abi/encodeFunctionData.js'
+import { toHex } from '../../../../utils/encoding/toHex.js'
+import { contractDeployerAbi } from '../../constants/abis.js'
+import { accountAbstractionVersion1 } from '../../constants/contract.js'
+import type { ContractDeploymentType } from '../../types/contract.js'
+import { hashBytecode } from '../hashBytecode.js'
+
+const docsPath = '/docs/contract/encodeDeployData'
+
+export type EncodeDeployDataParameters<
+  abi extends Abi | readonly unknown[] = Abi,
+  hasConstructor = abi extends Abi
+    ? Abi extends abi
+      ? true
+      : [Extract<abi[number], { type: 'constructor' }>] extends [never]
+        ? false
+        : true
+    : true,
+  allArgs = ContractConstructorArgs<abi>,
+> = EncodeDeployDataParameters_<abi, hasConstructor, allArgs> & {
+  deploymentType?: ContractDeploymentType | undefined
+  salt?: Hash | undefined
+}
+
+export function encodeDeployData<const abi extends Abi | readonly unknown[]>(
+  parameters: EncodeDeployDataParameters<abi>,
+): EncodeDeployDataReturnType {
+  const { abi, args, bytecode, deploymentType, salt } =
+    parameters as EncodeDeployDataParameters
+
+  if (!args || args.length === 0) {
+    const { functionName, argsContractDeployer } = getDeploymentDetails(
+      deploymentType,
+      salt ?? zeroHash,
+      toHex(hashBytecode(bytecode)),
+      '0x',
+    )
+    return encodeFunctionData({
+      abi: contractDeployerAbi,
+      functionName,
+      args: argsContractDeployer,
+    })
+  }
+
+  const description = abi.find((x) => 'type' in x && x.type === 'constructor')
+  if (!description) throw new AbiConstructorNotFoundError({ docsPath })
+  if (!('inputs' in description))
+    throw new AbiConstructorParamsNotFoundError({ docsPath })
+  if (!description.inputs || description.inputs.length === 0)
+    throw new AbiConstructorParamsNotFoundError({ docsPath })
+
+  const data = encodeAbiParameters(description.inputs, args)
+  const { functionName, argsContractDeployer } = getDeploymentDetails(
+    deploymentType,
+    salt ?? zeroHash,
+    toHex(hashBytecode(bytecode)),
+    data,
+  )
+
+  return encodeFunctionData({
+    abi: contractDeployerAbi,
+    functionName,
+    args: argsContractDeployer,
+  })
+}
+
+function getDeploymentDetails(
+  deploymentType: ContractDeploymentType,
+  salt: Hash,
+  bytecodeHash: Hex,
+  data: Hex,
+): {
+  functionName: string
+  argsContractDeployer: readonly unknown[]
+} {
+  const contractDeploymentArgs = [salt, bytecodeHash, data]
+
+  const deploymentOptions = {
+    create: {
+      functionName: 'create',
+      argsContractDeployer: contractDeploymentArgs,
+    },
+    create2: {
+      functionName: 'create2',
+      argsContractDeployer: contractDeploymentArgs,
+    },
+    createAccount: {
+      functionName: 'createAccount',
+      argsContractDeployer: [
+        ...contractDeploymentArgs,
+        accountAbstractionVersion1,
+      ],
+    },
+    create2Account: {
+      functionName: 'create2Account',
+      argsContractDeployer: [
+        ...contractDeploymentArgs,
+        accountAbstractionVersion1,
+      ],
+    },
+  }
+
+  const deploymentKey = deploymentType || 'create'
+  return deploymentOptions[deploymentKey]
+}

package/chains/zksync/utils/getEip712Domain.ts

@@ -1,3 +1,4 @@
+import { toHex } from '../../../utils/encoding/toHex.js'
 import type { EIP712DomainFn } from '../types/eip712.js'
 import type {
   ZkSyncEIP712TransactionSignable,
@@ -5,6 +6,7 @@ import type {
   ZkSyncTransactionSerializableEIP712,
 } from '../types/transaction.js'
 import { assertEip712Transaction } from './assertEip712Transaction.js'
+import { hashBytecode } from './hashBytecode.js'
 
 export const getEip712Domain: EIP712DomainFn<
   ZkSyncTransactionSerializable,
@@ -77,7 +79,7 @@ function transactionToMessage(
     nonce: nonce ? BigInt(nonce) : 0n,
     value: value ?? 0n,
     data: data ? data : '0x0',
-    factoryDeps: factoryDeps ?? [],
-    paymasterInput: paymasterInput ? paymasterInput : '0x0',
+    factoryDeps: factoryDeps?.map((dep) => toHex(hashBytecode(dep))) ?? [],
+    paymasterInput: paymasterInput ? paymasterInput : '0x',
   }
 }

package/chains/zksync/utils/hashBytecode.ts

@@ -0,0 +1,48 @@
+import type { Hex } from '../../../types/misc.js'
+import { pad } from '../../../utils/data/pad.js'
+import { toBytes } from '../../../utils/encoding/toBytes.js'
+import { sha256 } from '../../../utils/hash/sha256.js'
+import { maxBytecodeSize } from '../constants/number.js'
+import {
+  BytecodeLengthExceedsMaxSizeError,
+  BytecodeLengthInWordsMustBeOddError,
+  BytecodeLengthMustBeDivisibleBy32Error,
+} from '../errors/bytecode.js'
+
+export function hashBytecode(bytecode: Hex): Uint8Array {
+  const bytecodeBytes = toBytes(bytecode)
+  if (bytecodeBytes.length % 32 !== 0)
+    throw new BytecodeLengthMustBeDivisibleBy32Error({
+      givenLength: bytecodeBytes.length,
+    })
+
+  if (bytecodeBytes.length > maxBytecodeSize)
+    throw new BytecodeLengthExceedsMaxSizeError({
+      givenLength: bytecodeBytes.length,
+      maxBytecodeSize,
+    })
+
+  const hashStr = sha256(bytecodeBytes)
+  const hash = toBytes(hashStr)
+
+  // Note that the length of the bytecode
+  // should be provided in 32-byte words.
+  const bytecodeLengthInWords = bytecodeBytes.length / 32
+  if (bytecodeLengthInWords % 2 === 0) {
+    throw new BytecodeLengthInWordsMustBeOddError({
+      givenLengthInWords: bytecodeLengthInWords,
+    })
+  }
+
+  const bytecodeLength = toBytes(bytecodeLengthInWords)
+
+  // The bytecode should always take the first 2 bytes of the bytecode hash,
+  // so we pad it from the left in case the length is smaller than 2 bytes.
+  const bytecodeLengthPadded = pad(bytecodeLength, { size: 2 })
+
+  const codeHashVersion = new Uint8Array([1, 0])
+  hash.set(codeHashVersion, 0)
+  hash.set(bytecodeLengthPadded, 2)
+
+  return hash
+}

package/errors/version.ts

@@ -1 +1 @@
-export const version = '0.0.0-main.20240324T200829'
+export const version = '0.0.0-main.20240324T211636'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "0.0.0-main.20240324T200829",
+  "version": "0.0.0-main.20240324T211636",
   "type": "module",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",