@exodus/ethereum-api 9.0.0-alpha.3 → 9.0.1

package/src/index.js

@@ -1,15 +1,121 @@
 // Ideally, we should reduce the exports to just api.
 // If the client is importing one module specifically,
 // it's breaking the encapsulation
-export * from './eth-like-util'
-export * from './gas-estimation'
-export { getServer, getServerByName } from './exodus-eth-server/server-map'
-export * from './tx-log'
-export * from './get-balances'
-export * from './staking'
-export * from './simulate-tx'
-export * from './allowance'
-export * from './optimism-gas'
-export * from './number-utils'
-export { txSendFactory, getFeeInfo } from './tx-send'
-export { createAssetFactory } from './create-asset'
+export {
+  FORWARDER_CONTRACT_CODE,
+  isContractAddress,
+  isContractAddressCached,
+  isForwarderContract,
+  isForwarderContractCached,
+  getNonce,
+  estimateGas,
+  getBalance,
+  getBalanceProxied,
+  getTokenBalance,
+  getTokenBalanceFromNode,
+  transactionExists,
+  getTransaction,
+  getIsForwarderContract,
+  getERC20Params,
+  getEIP7702Delegation,
+} from './eth-like-util.js'
+
+export {
+  DEFAULT_CONTRACT_GAS_LIMIT,
+  DEFAULT_GAS_LIMIT_MULTIPLIER,
+  estimateGasLimit,
+  fetchGasLimit,
+  scaleGasLimitEstimate,
+} from './gas-estimation.js'
+
+export { createEvmServer, getServer } from './exodus-eth-server/index.js'
+
+export {
+  EthereumMonitor,
+  EthereumNoHistoryMonitor,
+  ClarityMonitor,
+  getOptimisticTxLogEffects,
+} from './tx-log/index.js'
+
+export { getStakingHistoryBalance, getBalancesFactory } from './get-balances.js'
+export { getHistoricalBalanceFactory } from './get-historical-balance.js'
+export { createEncodeMultisigContract } from './multisig-address.js'
+
+export { FantomStaking, stakingProviderClientFactory } from './staking/index.js'
+export { EthLikeRpcRequestAccumulator } from './multicall3/index.js'
+export { createCachedStakingRead } from './staking/cached-read.js'
+export { ethereumStakingDeps } from './staking/ethereum/deps.js'
+export { getEthereumStakingInfo, createEthereumStakingService } from './staking/ethereum/service.js'
+export { EthereumStaking } from './staking/ethereum/api.js'
+export {
+  isEthereumStakingTx,
+  isEthereumDelegate,
+  isEthereumUndelegatePending,
+  isEthereumUndelegate,
+  isEthereumClaimUndelegate,
+} from './staking/ethereum/staking-utils.js'
+export { MaticStakingApi } from './staking/matic/index.js'
+export {
+  EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
+  STAKING_MANAGER_ADDR,
+} from './staking/matic/addresses.js'
+export {
+  isPolygonTx,
+  isPolygonDelegate,
+  isPolygonUndelegate,
+  isPolygonReward,
+  isPolygonClaimUndelegate,
+  isPendingPolygonUndelegateTxInEthereumTxLog,
+} from './staking/matic/matic-staking-utils.js'
+
+export { fetchTxPreview } from './simulate-tx/fetch-tx-preview.js'
+export { maybeRemoveDuplicates, retrieveSideEffects } from './simulate-tx/simulate-eth-tx.js'
+export { simulateTransactions } from './simulation/simulate-transactions.js'
+
+export {
+  isZeroAllowanceAsset,
+  getSpendingAllowance,
+  isSpendingApprovalRequired,
+  buildApproveTx,
+  buildLegacyApproveTx,
+  createApprove,
+  createApproveSpendingTokens,
+  APPROVAL_GAS_LIMIT,
+  ZERO_ALLOWANCE_ASSETS,
+} from './allowance/index.js'
+
+export { estimateL1DataFeeFactory, getL1GetFeeFactory } from './optimism-gas/index.js'
+
+export { getAggregateTransactionPricing } from './get-fee.js'
+
+export {
+  fromHexToString,
+  fromHexToBigInt,
+  addHexPrefix,
+  removeHexPrefix,
+  splitIn32BytesArray,
+  removeLeadingZeroes,
+  fromHexToBN,
+} from './number-utils.js'
+
+export {
+  EVM_ERROR_REASONS,
+  EVM_ERROR_TYPES,
+  getEvmErrorReason,
+  withErrorReason,
+  EthLikeError,
+} from './error-wrapper.js'
+
+export { txSendFactory } from './tx-send/index.js'
+
+export { createAssetFactory } from './create-asset.js'
+export { createCheckTx } from './check-tx/index.js'
+
+export { moveFundsFactory } from './move-funds.js'
+
+export { createContractBlackListCheck } from './create-asset-utils.js'
+
+export {
+  createAssetPluginFactory,
+  fromAddEthereumChainParameterToFactoryParams,
+} from './create-asset-plugin-factory.js'

package/src/move-funds.js

@@ -0,0 +1,153 @@
+import { signUnsignedTx } from '@exodus/ethereum-lib'
+import { addHexPrefix, isValidPrivate, privateToAddress, toBuffer } from '@exodus/ethereumjs/util'
+import assert from 'minimalistic-assert'
+
+import { getNonce, getTokenBalanceFromNode } from './eth-like-util.js'
+import { fetchGasLimit } from './gas-estimation.js'
+import { AmountIncludesFeeUnderflowError } from './tx-create.js'
+
+export const moveFundsFactory = ({ baseAssetName, assetClientInterface, createTx, server }) => {
+  assert(baseAssetName, 'baseAssetName is required')
+  assert(assetClientInterface, 'assetClientInterface is required')
+  assert(createTx, 'createTx is required')
+  assert(server, 'server is required')
+
+  async function prepareSendFundsTx({
+    assetName,
+    input,
+    toAddress,
+    walletAccount,
+    MoveFundsError,
+  }) {
+    assert(assetName, 'assetName is required')
+    assert(input, 'input is required')
+
+    assert(walletAccount, 'walletAccount is required')
+    assert(MoveFundsError, 'MoveFundsError is required')
+
+    const assets = await assetClientInterface.getAssetsForNetwork({ baseAssetName })
+    const asset = assets[assetName]
+    assert(asset, 'asset is required')
+
+    assert(toAddress && asset.baseAsset.address.validate(toAddress), 'valid toAddress is required')
+
+    let privateKey
+    try {
+      const hexKey = addHexPrefix(input.trim())
+      if (typeof hexKey !== 'string' || hexKey.length !== 66) throw new Error('invalid length')
+      privateKey = toBuffer(hexKey)
+      if (!isValidPrivate(privateKey)) throw new Error('invalid key')
+    } catch {
+      throw new MoveFundsError('private-key-invalid')
+    }
+
+    const fromAddress = `0x${privateToAddress(privateKey).toString('hex')}`
+
+    if (fromAddress === toAddress.toLowerCase()) {
+      throw new MoveFundsError('private-key-own-key', { fromAddress })
+    }
+
+    const isToken = asset.name !== baseAssetName
+
+    const [nonce, rawEthBalance] = await Promise.all([
+      getNonce({ asset: asset.baseAsset, address: fromAddress }),
+      server.getBalanceProxied(fromAddress),
+    ])
+
+    const ethBalance = asset.baseAsset.currency.baseUnit(rawEthBalance)
+
+    let amount = ethBalance
+    if (isToken) {
+      const rawTokenBalance = await getTokenBalanceFromNode({ asset, address: fromAddress })
+      amount = asset.currency.baseUnit(rawTokenBalance)
+    }
+
+    if (amount.isZero) {
+      throw new MoveFundsError('balance-zero', { fromAddress })
+    }
+
+    const feeData = await assetClientInterface.getFeeData({ assetName })
+
+    const gasLimit = await fetchGasLimit({
+      asset,
+      feeData,
+      fromAddress,
+      toAddress,
+      amount,
+      // `isSendAll` and `amountIncludesFee` are no-ops on the token branch
+      // (both gated on `!isToken` / `!isEthereumLikeToken(asset)` downstream),
+      // so don't pass them. Keeps the API surface honest about which flags
+      // actually take effect for each branch.
+      ...(isToken ? null : { isSendAll: true }),
+    })
+
+    let createTxResult
+    try {
+      createTxResult = await createTx({
+        asset,
+        walletAccount,
+        fromAddress,
+        // Native sweep: pass the full balance and let createTx subtract the
+        // accurate fee. Token sweep: pass the full token balance unchanged
+        // (the native gas fee is paid separately from native balance).
+        address: toAddress,
+        amount,
+        nonce,
+        gasLimit,
+        gasPrice: feeData.gasPrice,
+        // TODO: drop this. Move funds has no fee picker, so it's always
+        // `feeData.gasPrice` (same as `gasPrice` above) and a no-op anyway.
+        // If we ever need a custom fee, thread it through prepareSendFundsTx.
+        customFee: feeData.gasPrice,
+        // Both flags are no-ops for tokens (see fetchGasLimit call above).
+        ...(isToken ? null : { isSendAll: true, amountIncludesFee: true }),
+      })
+    } catch (err) {
+      // createTx throws `AmountIncludesFeeUnderflowError` for the native
+      // sweep when the accurate fee (including OP-stack L1 data fee) exceeds
+      // the balance we passed in. Translate to the typed MoveFundsError so
+      // consumers (mobile/desktop MoveFunds screens) render the right copy.
+      if (!isToken && err instanceof AmountIncludesFeeUnderflowError) {
+        throw new MoveFundsError('balance-negative', { fromAddress })
+      }
+
+      throw err
+    }
+
+    // Token sweep equivalent of the native underflow gate: createTx doesn't
+    // validate ETH balance vs gas for token transfers, so check it here using
+    // the authoritative fee returned from `calculateFee`. This catches the
+    // OP-stack edge case where balance covers `gasPrice * gasLimit` but not
+    // the additional L1 data fee.
+    if (isToken && ethBalance.sub(createTxResult.fee).isNegative) {
+      throw new MoveFundsError('token-fee-insufficient', { fromAddress })
+    }
+
+    // Trust createTx for both amount and fee. For native sweep `amount` is
+    // the post-subtraction value (input balance minus accurate fee). For
+    // token sweep `amount` is the input token balance unchanged, since we
+    // don't pass `amountIncludesFee`. In both cases `fee` includes the
+    // OP-stack L1 data fee from `calculateFee`, which matters more for
+    // tokens than for native because ERC-20 calldata is larger.
+    return {
+      fromAddress,
+      toAddress,
+      amount: createTxResult.amount,
+      fee: createTxResult.fee,
+      privateKey,
+      unsignedTx: createTxResult.unsignedTx,
+    }
+  }
+
+  const sendFunds = async ({ privateKey, unsignedTx }) => {
+    assert(privateKey, 'privateKey is required')
+    assert(unsignedTx, 'unsignedTx is required')
+
+    const { rawTx } = await signUnsignedTx(unsignedTx, privateKey)
+    const txId = await server.sendRawTransaction(rawTx.toString('hex'))
+
+    return { txId }
+  }
+
+  return { prepareSendFundsTx, sendFunds }
+}

package/src/multicall3/index.js

@@ -0,0 +1,212 @@
+import { memoize } from '@exodus/basic-utils'
+import { ABI } from '@exodus/ethereum-lib'
+import { bufferToHex } from '@exodus/ethereumjs/util'
+import SolidityContract from '@exodus/solidity-contract'
+import assert from 'minimalistic-assert'
+
+import { EthLikeServerBase } from '../exodus-eth-server/eth-like-server.js'
+import { BLOCK_TAG_LATEST } from '../tx-send/nonce-utils.js'
+
+const assertValidMulticall3BlockTag = (blockTag) =>
+  assert(blockTag === BLOCK_TAG_LATEST, 'blockTag must be "latest" for multicall3')
+
+const SUPPORTED_METHODS = new Set(['eth_getBalance', 'eth_blockNumber', 'eth_call'])
+
+const assertSupportedMethod = (method) => {
+  assert(
+    SUPPORTED_METHODS.has(method),
+    `method "${method}" is not supported for static call batching`
+  )
+}
+
+const getMulticall3Contract = memoize(() => new SolidityContract(ABI.multicall3))
+
+export class EthLikeRpcRequestAccumulator extends EthLikeServerBase {
+  static REQUEST_PARSER_NOOP = ({ result }) => result
+
+  static REQUEST_PARSER_UINT256 = ({ result }) => `0x${BigInt(result).toString(16)}`
+
+  static REQUEST_PARSER_BALANCE_OF = ({ originalRequest, result }) => {
+    const {
+      params: [{ to: tokenAddress }],
+    } = originalRequest
+
+    return {
+      confirmed: {
+        [tokenAddress]: BigInt(result).toString(),
+      },
+    }
+  }
+
+  #requestParser = null
+  #requests = []
+
+  #withRequestParser(functionName, requestParser) {
+    assert(typeof functionName === 'string', 'expected functionName')
+    assert(typeof requestParser === 'function', 'expected requestParser')
+
+    return (...args) => {
+      assert(!this.#requestParser) // invariant
+
+      this.#requestParser = requestParser
+      const result = super[functionName](...args)
+      this.#requestParser = null
+
+      return result
+    }
+  }
+
+  _serializeRequest({ originalRequest }) {
+    return super.buildRequest(originalRequest)
+  }
+
+  async _execute({ requests, server }) {
+    return server.sendBatchRequest(requests.map(({ request }) => request))
+  }
+
+  buildRequest(originalRequest) {
+    const { method, params } = originalRequest
+    assertSupportedMethod(method)
+
+    if (method === 'eth_getBalance' || method === 'eth_call') {
+      const tag = params[1]
+      assertValidMulticall3BlockTag(tag)
+    }
+
+    if (method === 'eth_call') {
+      const { from } = params[0]
+      assert(!from, 'cannot specify "from"')
+    }
+
+    void this.#requests.push({
+      originalRequest,
+      request: this._serializeRequest({ originalRequest }),
+      requestParser: this.#requestParser ?? null,
+    })
+
+    return this
+  }
+
+  balanceOfRequest(...args) {
+    return this.#withRequestParser(
+      'balanceOfRequest',
+      EthLikeRpcRequestAccumulator.REQUEST_PARSER_BALANCE_OF
+    )(...args)
+  }
+
+  blockNumberRequest(...args) {
+    return this.#withRequestParser(
+      'blockNumberRequest',
+      EthLikeRpcRequestAccumulator.REQUEST_PARSER_UINT256
+    )(...args)
+  }
+
+  getBalanceRequest(...args) {
+    return this.#withRequestParser(
+      'getBalanceRequest',
+      EthLikeRpcRequestAccumulator.REQUEST_PARSER_UINT256
+    )(...args)
+  }
+
+  contractStaticCallFromRequest(contract, functionName, ...args) {
+    const requestParser = ({ result }) => contract[functionName].parse(result)
+    return this.#withRequestParser('contractStaticCallFromRequest', requestParser)(
+      contract,
+      functionName,
+      ...args
+    )
+  }
+
+  contractStaticCallRequest(contract, functionName, ...args) {
+    return this.contractStaticCallFromRequest(contract, functionName, undefined, ...args)
+  }
+
+  length() {
+    return this.#requests.length
+  }
+
+  reset() {
+    this.#requests.length = 0
+  }
+
+  async flush(server) {
+    assert(server, 'expected server')
+
+    const requests = [...this.#requests]
+    this.reset()
+
+    if (requests.length === 0) return []
+
+    const results = await this._execute({ requests, server })
+
+    return results.map((result, i) => {
+      const request = requests[i]
+      assert(request)
+
+      const { requestParser: maybeRequestParser, originalRequest } = request
+
+      const requestParser = maybeRequestParser ?? EthLikeRpcRequestAccumulator.REQUEST_PARSER_NOOP
+
+      return requestParser({ originalRequest, result })
+    })
+  }
+}
+
+export class EthLikeMulticall3RpcRequestAccumulator extends EthLikeRpcRequestAccumulator {
+  #multicall3Address
+  #multicall3Contract
+
+  constructor({ multicall3Address }) {
+    super()
+
+    assert(typeof multicall3Address === 'string')
+    this.#multicall3Address = multicall3Address
+    this.#multicall3Contract = getMulticall3Contract()
+  }
+
+  _serializeRequest({ originalRequest: { method, params } }) {
+    switch (method) {
+      case 'eth_getBalance':
+        return {
+          address: this.#multicall3Address,
+          calldata: bufferToHex(this.#multicall3Contract.getEthBalance.build(params[0])),
+        }
+      case 'eth_blockNumber':
+        return {
+          address: this.#multicall3Address,
+          calldata: bufferToHex(this.#multicall3Contract.getBlockNumber.build()),
+        }
+      case 'eth_call': {
+        const [data] = params
+        const { to, data: calldata } = data
+        return { address: to, calldata }
+      }
+
+      default:
+        assert(false)
+    }
+  }
+
+  async _execute({ requests, server }) {
+    const data = await server.ethCall({
+      data: bufferToHex(
+        this.#multicall3Contract.aggregate.build(
+          requests.map(({ request: { address, calldata } }) => [address, calldata])
+        )
+      ),
+      to: this.#multicall3Address,
+    })
+
+    const multicall3Result = this.#multicall3Contract.decodeOutput({ data, method: 'aggregate' })
+
+    assert(
+      Array.isArray(multicall3Result) && multicall3Result.length === 2,
+      'invalid multicall3Result'
+    )
+
+    const results = multicall3Result[1].map((buf) => bufferToHex(buf))
+    assert(results.length === requests.length)
+
+    return results
+  }
+}

package/src/multisig-address.js

@@ -0,0 +1,146 @@
+import { memoize } from '@exodus/basic-utils'
+import { hash } from '@exodus/crypto/hash'
+import { publicKeyIsValid } from '@exodus/crypto/secp256k1'
+import { toChecksumAddress } from '@exodus/ethereumjs/util'
+import SolidityContract from '@exodus/solidity-contract'
+
+const keccak256 = async (data) => hash('keccak256', data)
+
+// Limit multisig keys to 16 for now
+const MAX_PUBKEYS = 16
+
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
+
+// This derives the counterfactual CREATE2 address of OUR canonical Safe 4337
+// deployment (fixed singleton, modules and salt nonce, so owners + threshold
+// fully determine the address). It intentionally does NOT resolve addresses of
+// arbitrary pre-existing Safes, whose setup we cannot reconstruct from pubkeys.
+// https://docs.safe.global/advanced/erc-4337/guides/permissionless-detailed
+
+// Safe{Core} Protocol deployments for the Safe 4337 setup, chainId 1.
+// https://github.com/safe-global/safe-modules-deployments
+const ADD_MODULES_LIB_ADDRESS = '0x8EcD4ec46D4D2a6B64fE960B3D64e8B94B2234eb'
+const SAFE_4337_MODULE_ADDRESS = '0xa581c4A4DB7175302464fF3C06380BC3270b4037'
+const PROXY_FACTORY_ADDRESS = '0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67'
+
+// enableModules([SAFE_4337_MODULE_ADDRESS]) calldata passed to setup()
+const SETUP_DATA = `0x8d0dc49f00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000001000000000000000000000000${SAFE_4337_MODULE_ADDRESS.slice(2)}`
+
+// SALT_NONCE is protocol-kit's getChainSpecificDefaultSaltNonce(1n). Careful
+// reproducing it: the derivation is stringly, NOT abi.encodePacked of numbers.
+// PREDETERMINED_SALT_NONCE is a hex *string*, `+ chainId` is JS *string
+// concatenation*, and toHex() *utf8-encodes* the resulting text before hashing:
+//
+//  PREDETERMINED_SALT_NONCE = '0x' + keccak256(utf8('Safe Account Abstraction'))
+//                           = '0xb1073742015cbcf5a3a4d9d1ae33ecf619439710b89475f92e2abd2117e90f90'
+//  SALT_NONCE = keccak256(utf8(PREDETERMINED_SALT_NONCE + '1')) // chainId 1
+//
+// i.e. keccak256 of the 67 ASCII characters '0xb107...f901'
+const SALT_NONCE = '0x69b348339eea4ed93f9d11931c3b894c8f9d8c7663a053024b11cb7eb4e5a1f6'
+
+// SafeProxy creation code with the SafeL2 singleton (0x41675C09...) constructor argument appended
+const INIT_CODE =
+  '0x608060405234801561001057600080fd5b506040516101e63803806101e68339818101604052602081101561003357600080fd5b8101908080519060200190929190505050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614156100ca576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260228152602001806101c46022913960400191505060405180910390fd5b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505060ab806101196000396000f3fe608060405273ffffffffffffffffffffffffffffffffffffffff600054167fa619486e0000000000000000000000000000000000000000000000000000000060003514156050578060005260206000f35b3660008037600080366000845af43d6000803e60008114156070573d6000fd5b3d6000f3fea264697066735822122003d1488ee65e08fa41e58e888a9865554c535f2c77126a82cb4c0f917f31441364736f6c63430007060033496e76616c69642073696e676c65746f6e20616464726573732070726f766964656400000000000000000000000041675c099f32341bf84bfc5382af534df5c7461a'
+
+const SAFE_SETUP_ABI = [
+  {
+    inputs: [
+      { internalType: 'address[]', name: '_owners', type: 'address[]' },
+      { internalType: 'uint256', name: '_threshold', type: 'uint256' },
+      { internalType: 'address', name: 'to', type: 'address' },
+      { internalType: 'bytes', name: 'data', type: 'bytes' },
+      { internalType: 'address', name: 'fallbackHandler', type: 'address' },
+      { internalType: 'address', name: 'paymentToken', type: 'address' },
+      { internalType: 'uint256', name: 'payment', type: 'uint256' },
+      { internalType: 'address payable', name: 'paymentReceiver', type: 'address' },
+    ],
+    name: 'setup',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+]
+
+const getSafeContract = memoize(() => new SolidityContract(SAFE_SETUP_ABI, '', true))
+
+const SALT_NONCE_BUFFER = Buffer.from(SALT_NONCE.slice(2), 'hex')
+
+export const createEncodeMultisigContract = ({ chainId, encodePublic }) => {
+  // The Safe deployment constants above (addresses and SALT_NONCE) only derive
+  // valid addresses for chainId 1, so refuse other chains instead of silently
+  // deriving an incorrect address
+  if (chainId !== 1) {
+    throw new Error(`asset.encodeMultisigContract is not supported for chainId ${chainId}`)
+  }
+
+  return async (publicKeys, meta = Object.create(null)) => {
+    if (
+      !Array.isArray(publicKeys) ||
+      publicKeys.some((k) => !Buffer.isBuffer(k) || !publicKeyIsValid({ publicKey: k }))
+    ) {
+      throw new Error('publicKeys must be an Array of Buffers representing valid public keys')
+    }
+
+    const { threshold = publicKeys.length, version = 0 } = meta
+
+    if (publicKeys.length <= 0 || publicKeys.length > MAX_PUBKEYS) {
+      throw new Error(`asset.encodeMultisigContract supports from 1 to ${MAX_PUBKEYS} pubKeys`)
+    }
+
+    if (!Number.isSafeInteger(version)) {
+      throw new TypeError('asset.encodeMultisigContract requires meta.version to be an integer')
+    }
+
+    // Only support version 0 for now
+    if (version !== 0) {
+      throw new Error(`asset.encodeMultisigContract does not support version ${version}`)
+    }
+
+    if (!Number.isSafeInteger(threshold) || threshold <= 0 || threshold > MAX_PUBKEYS) {
+      throw new Error(
+        `asset.encodeMultisigContract requires meta.threshold to be an integer between 1 and ${MAX_PUBKEYS}`
+      )
+    }
+
+    if (threshold > publicKeys.length) {
+      throw new Error('threshold must be <= publicKeys.length')
+    }
+
+    // Owners are intentionally NOT sorted: the Safe address depends on the owner
+    // order in setup(), so publicKeys must be passed in a stable, agreed-upon order
+    const owners = publicKeys.map((publicKey) => encodePublic(publicKey))
+
+    if (new Set(owners.map((o) => o.toLowerCase())).size !== owners.length) {
+      throw new Error('publicKeys must not contain any duplicates')
+    }
+
+    const setupData = getSafeContract().setup.build(
+      owners,
+      threshold,
+      ADD_MODULES_LIB_ADDRESS,
+      SETUP_DATA,
+      SAFE_4337_MODULE_ADDRESS,
+      ZERO_ADDRESS,
+      0,
+      ZERO_ADDRESS
+    )
+
+    // CREATE2: keccak256(0xff ++ proxyFactory ++ keccak256(keccak256(setupData) ++ saltNonce) ++ keccak256(initCode))[12:]
+    const [setupDataHash, initCodeHash] = await Promise.all([
+      keccak256(setupData),
+      keccak256(Buffer.from(INIT_CODE.slice(2), 'hex')),
+    ])
+
+    const salt = await keccak256([setupDataHash, SALT_NONCE_BUFFER])
+
+    const create2Hash = await keccak256([
+      Buffer.from('ff', 'hex'),
+      Buffer.from(PROXY_FACTORY_ADDRESS.slice(2), 'hex'),
+      salt,
+      initCodeHash,
+    ])
+    const address = create2Hash.slice(12)
+
+    return { address: toChecksumAddress('0x' + address.toString('hex')) }
+  }
+}