viem 0.0.0-main.20240322T015814 → 0.0.0-main.20240324T211636

package/chains/zksync/constants/abis.ts

@@ -0,0 +1,424 @@
+/* [ContractDeployer](https://github.com/matter-labs/era-system-contracts/blob/main/contracts/ContractDeployer.sol) */
+export const contractDeployerAbi = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'accountAddress',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'enum IContractDeployer.AccountNonceOrdering',
+        name: 'nonceOrdering',
+        type: 'uint8',
+      },
+    ],
+    name: 'AccountNonceOrderingUpdated',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'accountAddress',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'enum IContractDeployer.AccountAbstractionVersion',
+        name: 'aaVersion',
+        type: 'uint8',
+      },
+    ],
+    name: 'AccountVersionUpdated',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'deployerAddress',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'bytes32',
+        name: 'bytecodeHash',
+        type: 'bytes32',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'contractAddress',
+        type: 'address',
+      },
+    ],
+    name: 'ContractDeployed',
+    type: 'event',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'bytes32',
+        name: '_salt',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'bytes32',
+        name: '_bytecodeHash',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'bytes',
+        name: '_input',
+        type: 'bytes',
+      },
+    ],
+    name: 'create',
+    outputs: [
+      {
+        internalType: 'address',
+        name: '',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'payable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'bytes32',
+        name: '_salt',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'bytes32',
+        name: '_bytecodeHash',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'bytes',
+        name: '_input',
+        type: 'bytes',
+      },
+    ],
+    name: 'create2',
+    outputs: [
+      {
+        internalType: 'address',
+        name: '',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'payable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'bytes32',
+        name: '_salt',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'bytes32',
+        name: '_bytecodeHash',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'bytes',
+        name: '_input',
+        type: 'bytes',
+      },
+      {
+        internalType: 'enum IContractDeployer.AccountAbstractionVersion',
+        name: '_aaVersion',
+        type: 'uint8',
+      },
+    ],
+    name: 'create2Account',
+    outputs: [
+      {
+        internalType: 'address',
+        name: '',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'payable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'bytes32',
+        name: '',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'bytes32',
+        name: '_bytecodeHash',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'bytes',
+        name: '_input',
+        type: 'bytes',
+      },
+      {
+        internalType: 'enum IContractDeployer.AccountAbstractionVersion',
+        name: '_aaVersion',
+        type: 'uint8',
+      },
+    ],
+    name: 'createAccount',
+    outputs: [
+      {
+        internalType: 'address',
+        name: '',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'payable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: '_address',
+        type: 'address',
+      },
+    ],
+    name: 'extendedAccountVersion',
+    outputs: [
+      {
+        internalType: 'enum IContractDeployer.AccountAbstractionVersion',
+        name: '',
+        type: 'uint8',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'bytes32',
+        name: '_keccak256BytecodeHash',
+        type: 'bytes32',
+      },
+    ],
+    name: 'forceDeployKeccak256',
+    outputs: [],
+    stateMutability: 'payable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: 'bytes32',
+            name: 'bytecodeHash',
+            type: 'bytes32',
+          },
+          {
+            internalType: 'address',
+            name: 'newAddress',
+            type: 'address',
+          },
+          {
+            internalType: 'bool',
+            name: 'callConstructor',
+            type: 'bool',
+          },
+          {
+            internalType: 'uint256',
+            name: 'value',
+            type: 'uint256',
+          },
+          {
+            internalType: 'bytes',
+            name: 'input',
+            type: 'bytes',
+          },
+        ],
+        internalType: 'struct ContractDeployer.ForceDeployment',
+        name: '_deployment',
+        type: 'tuple',
+      },
+      {
+        internalType: 'address',
+        name: '_sender',
+        type: 'address',
+      },
+    ],
+    name: 'forceDeployOnAddress',
+    outputs: [],
+    stateMutability: 'payable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: 'bytes32',
+            name: 'bytecodeHash',
+            type: 'bytes32',
+          },
+          {
+            internalType: 'address',
+            name: 'newAddress',
+            type: 'address',
+          },
+          {
+            internalType: 'bool',
+            name: 'callConstructor',
+            type: 'bool',
+          },
+          {
+            internalType: 'uint256',
+            name: 'value',
+            type: 'uint256',
+          },
+          {
+            internalType: 'bytes',
+            name: 'input',
+            type: 'bytes',
+          },
+        ],
+        internalType: 'struct ContractDeployer.ForceDeployment[]',
+        name: '_deployments',
+        type: 'tuple[]',
+      },
+    ],
+    name: 'forceDeployOnAddresses',
+    outputs: [],
+    stateMutability: 'payable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: '_address',
+        type: 'address',
+      },
+    ],
+    name: 'getAccountInfo',
+    outputs: [
+      {
+        components: [
+          {
+            internalType: 'enum IContractDeployer.AccountAbstractionVersion',
+            name: 'supportedAAVersion',
+            type: 'uint8',
+          },
+          {
+            internalType: 'enum IContractDeployer.AccountNonceOrdering',
+            name: 'nonceOrdering',
+            type: 'uint8',
+          },
+        ],
+        internalType: 'struct IContractDeployer.AccountInfo',
+        name: 'info',
+        type: 'tuple',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: '_sender',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: '_senderNonce',
+        type: 'uint256',
+      },
+    ],
+    name: 'getNewAddressCreate',
+    outputs: [
+      {
+        internalType: 'address',
+        name: 'newAddress',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'pure',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: '_sender',
+        type: 'address',
+      },
+      {
+        internalType: 'bytes32',
+        name: '_bytecodeHash',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'bytes32',
+        name: '_salt',
+        type: 'bytes32',
+      },
+      {
+        internalType: 'bytes',
+        name: '_input',
+        type: 'bytes',
+      },
+    ],
+    name: 'getNewAddressCreate2',
+    outputs: [
+      {
+        internalType: 'address',
+        name: 'newAddress',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'enum IContractDeployer.AccountAbstractionVersion',
+        name: '_version',
+        type: 'uint8',
+      },
+    ],
+    name: 'updateAccountVersion',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'enum IContractDeployer.AccountNonceOrdering',
+        name: '_nonceOrdering',
+        type: 'uint8',
+      },
+    ],
+    name: 'updateNonceOrdering',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+]

package/chains/zksync/constants/address.ts

@@ -0,0 +1,2 @@
+export const contractDeployerAddress =
+  '0x0000000000000000000000000000000000008006' as const

package/chains/zksync/constants/contract.ts

@@ -0,0 +1,2 @@
+export const accountAbstractionVersionNone = 0
+export const accountAbstractionVersion1 = 1

package/chains/zksync/constants/number.ts

@@ -0,0 +1,3 @@
+import { maxUint16 } from '../../../constants/number.js'
+
+export const maxBytecodeSize = maxUint16 * 32n

package/chains/zksync/decorators/eip712.ts

@@ -1,8 +1,14 @@
+import type { Abi } from 'abitype'
 import { writeContract } from '../../../actions/wallet/writeContract.js'
 import type { Client } from '../../../clients/createClient.js'
 import type { WalletActions } from '../../../clients/decorators/wallet.js'
 import type { Transport } from '../../../clients/transports/createTransport.js'
 import type { Account } from '../../../types/account.js'
+import {
+  type DeployContractParameters,
+  type DeployContractReturnType,
+  deployContract,
+} from '../actions/deployContract.js'
 import {
   type SendTransactionParameters,
   type SendTransactionReturnType,
@@ -112,6 +118,46 @@ export type Eip712WalletActions<
   signTransaction: <chainOverride extends ChainEIP712 | undefined = undefined>(
     args: SignTransactionParameters<chain, account, chainOverride>,
   ) => Promise<SignTransactionReturnType>
+  /**
+   * Deploys a contract to the network, given bytecode and constructor arguments using EIP712 transaction.
+   *
+   * - Docs: https://viem.sh/docs/contract/deployContract
+   * - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts/deploying-contracts
+   *
+   * @param args - {@link DeployContractParameters}
+   * @returns The [Transaction](https://viem.sh/docs/glossary/terms#transaction) hash. {@link DeployContractReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { zkSync } from 'viem/chains'
+   * import { deployContract } from 'viem/contract'
+   *
+   * const client = createWalletClient({
+   *   account: privateKeyToAccount('0x…'),
+   *   chain: zksync,
+   *   transport: custom(provider),
+   * })
+   * const hash = await client.deployContract(client, {
+   *   abi: [],
+   *   account: '0x…,
+   *   deploymentType: 'create',
+   *   bytecode: '0x608060405260405161083e38038061083e833981016040819052610...',
+   *   factoryDeps: ['0x608060405260405161083e38038061083e833981016040819052610...'],
+   *   gasPerPubdata: 50000n
+   * })
+   */
+  deployContract: <
+    const abi extends Abi | readonly unknown[],
+    chainOverride extends ChainEIP712 | undefined,
+  >(
+    args: DeployContractParameters<
+      abi,
+      ChainEIP712 | undefined,
+      Account | undefined,
+      chainOverride
+    >,
+  ) => Promise<DeployContractReturnType>
   /**
    * Executes a write function on a contract.
    *
@@ -175,6 +221,7 @@ export function eip712WalletActions() {
   ): Eip712WalletActions<chain, account> => ({
     sendTransaction: (args) => sendTransaction(client, args),
     signTransaction: (args) => signTransaction(client, args),
+    deployContract: (args) => deployContract(client, args),
     writeContract: (args) =>
       writeContract(
         Object.assign(client, {

package/chains/zksync/errors/bytecode.ts

@@ -0,0 +1,46 @@
+import { BaseError } from '../../../errors/base.js'
+
+export type BytecodeLengthExceedsMaxSizeErrorType =
+  BytecodeLengthExceedsMaxSizeError & {
+    name: 'BytecodeLengthExceedsMaxSizeError'
+  }
+
+export class BytecodeLengthExceedsMaxSizeError extends BaseError {
+  override name = 'BytecodeLengthExceedsMaxSizeError'
+  constructor({
+    givenLength,
+    maxBytecodeSize,
+  }: { givenLength: number; maxBytecodeSize: bigint }) {
+    super(
+      `Bytecode cannot be longer than ${maxBytecodeSize} bytes. Given length: ${givenLength}`,
+    )
+  }
+}
+
+export type BytecodeLengthInWordsMustBeOddErrorType =
+  BytecodeLengthInWordsMustBeOddError & {
+    name: 'BytecodeLengthInWordsMustBeOddError'
+  }
+
+export class BytecodeLengthInWordsMustBeOddError extends BaseError {
+  override name = 'BytecodeLengthInWordsMustBeOddError'
+  constructor({ givenLengthInWords }: { givenLengthInWords: number }) {
+    super(
+      `Bytecode length in 32-byte words must be odd. Given length in words: ${givenLengthInWords}`,
+    )
+  }
+}
+
+export type BytecodeLengthMustBeDivisibleBy32ErrorType =
+  BytecodeLengthMustBeDivisibleBy32Error & {
+    name: 'BytecodeLengthMustBeDivisibleBy32Error'
+  }
+
+export class BytecodeLengthMustBeDivisibleBy32Error extends BaseError {
+  override name = 'BytecodeLengthMustBeDivisibleBy32Error'
+  constructor({ givenLength }: { givenLength: number }) {
+    super(
+      `The bytecode length in bytes must be divisible by 32. Given length: ${givenLength}`,
+    )
+  }
+}

package/chains/zksync/formatters.ts

@@ -134,7 +134,13 @@ export const formatters = {
                   },
                 }
               : {}),
-            ...(args.factoryDeps ? { factoryDeps: args.factoryDeps } : {}),
+            ...(args.factoryDeps
+              ? {
+                  factoryDeps: args.factoryDeps.map((dep) =>
+                    Array.from(hexToBytes(dep)),
+                  ),
+                }
+              : {}),
             ...(args.customSignature
               ? {
                   customSignature: Array.from(hexToBytes(args.customSignature)),

package/chains/zksync/index.ts

@@ -22,6 +22,12 @@ export {
   type SignTransactionReturnType,
   signTransaction,
 } from './actions/signTransaction.js'
+export {
+  type DeployContractErrorType,
+  type DeployContractParameters,
+  type DeployContractReturnType,
+  deployContract,
+} from './actions/deployContract.js'
 
 export {
   zkSync,

package/chains/zksync/types/contract.ts

@@ -0,0 +1,6 @@
+export type ContractDeploymentType =
+  | 'create'
+  | 'create2'
+  | 'createAccount'
+  | 'create2Account'
+  | undefined

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]
+}