@exodus/ethereum-api 8.76.7 → 8.77.1

package/CHANGELOG.md

@@ -3,6 +3,31 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.77.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.77.0...@exodus/ethereum-api@8.77.1) (2026-07-09)
+
+
+### Features
+
+* add contract `staticcall` helper for `rpcRequestAccumulator` ([#8336](https://github.com/ExodusMovement/assets/issues/8336)) ([674f1a3](https://github.com/ExodusMovement/assets/commit/674f1a39c0a8fd5353b6ae7a19b79166f5aabfc9))
+* include recipient address state changes in simulation result (EVM + Solana) ([#8321](https://github.com/ExodusMovement/assets/issues/8321)) ([556bfde](https://github.com/ExodusMovement/assets/commit/556bfded420ca37692e53865cafd5688557ed283))
+
+
+### Bug Fixes
+
+* **ethereum-api:** guard batch RPC against non-array responses ([#8350](https://github.com/ExodusMovement/assets/issues/8350)) ([683dbab](https://github.com/ExodusMovement/assets/commit/683dbabf32ffd7c03a649c6b037cfed4665f108d))
+* lower ETH min staking amount ([#8319](https://github.com/ExodusMovement/assets/issues/8319)) ([461e4c4](https://github.com/ExodusMovement/assets/commit/461e4c4f46e58e3750363edb9d0b6cddbfae5478))
+
+
+
+## [8.77.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.76.7...@exodus/ethereum-api@8.77.0) (2026-06-29)
+
+
+### Features
+
+* **ethereum:** implement getHistoricalBalance via clarity absolute balance ([#8281](https://github.com/ExodusMovement/assets/issues/8281)) ([be202a9](https://github.com/ExodusMovement/assets/commit/be202a94d9734d7af8ed118d11d4cc38c3b5ef10))
+
+
+
 ## [8.76.7](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.76.6...@exodus/ethereum-api@8.76.7) (2026-06-26)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.76.7",
+  "version": "8.77.1",
   "description": "Transaction monitors, fee monitors, RPC with the blockchain node, and other networking code for Ethereum and EVM-based blockchains",
   "type": "module",
   "main": "src/index.js",
@@ -69,5 +69,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "c704777d72888bf3a94f3a7ddc1b0e57cda3e6dc"
+  "gitHead": "96337ab20f90e6fa96043f7d569a4f6527c04ebd"
 }

package/src/create-asset.js

@@ -41,7 +41,9 @@ import { createFeeData } from './fee-data/index.js'
 import { createGetBalanceForAddress } from './get-balance-for-address.js'
 import { getBalancesFactory } from './get-balances.js'
 import { getFeeFactory } from './get-fee.js'
+import { getHistoricalBalanceFactory } from './get-historical-balance.js'
 import { moveFundsFactory } from './move-funds.js'
+import { createEncodeMultisigContract } from './multisig-address.js'
 import { estimateL1DataFeeFactory, getL1GetFeeFactory } from './optimism-gas/index.js'
 import { createSendValidations } from './send-validations.js'
 import { serverBasedFeeMonitorFactoryFactory } from './server-based-fee-monitor.js'
@@ -171,18 +173,32 @@ export const createAssetFactory = ({
       encodePublic: encodePublicFactory({ chainId, useEip1191ChainIdChecksum }),
     }
 
+    // The Safe 4337 contract constants baked into the derivation are chainId 1 specific
+    const encodeMultisigContract =
+      chainId === 1
+        ? createEncodeMultisigContract({ chainId, encodePublic: keys.encodePublic })
+        : undefined
+
     const getBalances = getBalancesFactory({
       monitorType,
       useAbsoluteBalance: useAbsoluteBalanceAndNonce,
       rpcBalanceAssetNames,
     })
 
+    const historicalBalanceSupported = monitorType !== 'no-history'
+    const getHistoricalBalance = getHistoricalBalanceFactory({
+      assetClientInterface,
+      getBalances,
+    })
+
     const { createToken, getTokens } = createTokenFactory(
       {
         address,
         bip44,
         keys,
         getBalances,
+        getHistoricalBalance,
+        historicalBalance: historicalBalanceSupported,
         assetClientInterface,
         server,
         stakingConfiguration,
@@ -225,9 +241,11 @@ export const createAssetFactory = ({
       family: ASSET_FAMILY.EVM,
       feeMonitor: true,
       feesApi: true,
+      historicalBalance: historicalBalanceSupported,
       isMaxFeeAsset,
       isTestnet,
       moveFunds: true,
+      multisig: Boolean(encodeMultisigContract),
       nfts,
       noHistory: monitorType === 'no-history',
       signWithSigner: true,
@@ -336,6 +354,7 @@ export const createAssetFactory = ({
       features,
       getActivityTxs,
       getBalances,
+      ...(features.historicalBalance && { getHistoricalBalance }),
       getBalanceForAddress: createGetBalanceForAddress({ asset, server }),
       ...(getBlackListStatus && { getBlackListStatus }),
       getConfirmationsNumber: () => confirmationsNumber,
@@ -388,6 +407,7 @@ export const createAssetFactory = ({
       address,
       api,
       chainId,
+      ...(encodeMultisigContract && { encodeMultisigContract }),
       monitorType,
       estimateL1DataFee,
       forceGasLimitEstimation,

package/src/create-token-factory.js

@@ -37,6 +37,8 @@ const getActivityTxs = ({ txs }) => txs.filter((tx) => !smallbalanceTx(tx))
 const getCreateBaseToken =
   ({
     getBalances,
+    getHistoricalBalance,
+    historicalBalance,
     assetClientInterface,
     server,
     stakingConfiguration = Object.create(null),
@@ -53,6 +55,7 @@ const getCreateBaseToken =
       features: tokenFeatures,
       hasFeature: (feature) => !!tokenFeatures[feature], // @deprecated use api.features instead
       getBalances,
+      ...(historicalBalance && { getHistoricalBalance }),
       getTxLogFilter: name === 'polygon' ? getPolygonTxLogFilter : getTxLogFilter,
     }
 

package/src/exodus-eth-server/api-coin-nodes.js

@@ -34,17 +34,7 @@ export default class ApiCoinNodesServer extends EthLikeServerBase {
   async sendBatchRequest(batch) {
     if (isEmpty(batch)) return batch
     const responses = await this.request(batch)
-    const isValid = responses.every((response) => {
-      return !isNaN(response?.id) && response?.result !== undefined
-    })
-    if (responses.length !== batch.length || !isValid) {
-      throw new Error('Bad rpc batch response')
-    }
-
-    const keyed = responses.reduce((acc, response) => {
-      return { ...acc, [`${response.id}`]: response.result }
-    }, Object.create(null))
-    return batch.map((request) => keyed[`${request.id}`])
+    return this.parseBatchResponse({ batch, responses, errorMessage: 'Bad rpc batch response' })
   }
 
   async sendRequest(request) {

package/src/exodus-eth-server/clarity.js

@@ -216,18 +216,7 @@ export default class ClarityServer extends EthLikeServerBase {
   // Transport: WS only in ClarityServer, WS first → HTTP fallback in ClarityServerV2
   async sendBatchRequest(batch) {
     const responses = await this.sendRpcRequest(batch)
-    // FIXME: this falls apart if responses is not an array
-    const isValid = responses.every((response) => {
-      return !isNaN(response?.id) && response?.result !== undefined
-    })
-    if (responses.length !== batch.length || !isValid) {
-      throw new Error('Bad Response')
-    }
-
-    const keyed = responses.reduce((acc, response) => {
-      return { ...acc, [`${response.id}`]: response.result }
-    }, Object.create(null))
-    return batch.map((request) => keyed[`${request.id}`])
+    return this.parseBatchResponse({ batch, responses, errorMessage: 'Bad Response' })
   }
 
   // Transport: Uses sendRpcRequest - WS only in ClarityServer, WS first → HTTP fallback in ClarityServerV2

package/src/exodus-eth-server/eth-like-server-base.js

@@ -120,4 +120,39 @@ export default class EthLikeServerBase extends EventEmitter {
     assert(Array.isArray(txs), 'expected array txs')
     return this.buildRequest({ method: 'eth_sendBundle', params: [{ txs }] })
   }
+
+  /**
+   * Validates a JSON-RPC batch response, returning each `result` ordered to
+   * match `batch` (correlated by `id`, since responses can arrive out of order).
+   *
+   * @param {Array<{ id: number|string }>} args.batch - Requests sent, in the order results are expected.
+   * @param {unknown} args.responses - Raw transport payload; expected `[{ id, result }]` but treated as untrusted (gateways may return `{ message }` on error).
+   * @param {string} args.errorMessage - Thrown-error prefix per transport (e.g. `'Bad rpc batch response'`, `'Bad Response'`).
+   * @returns {unknown[]} Each request's `result`, ordered to match `batch`.
+   * @throws {Error} When `responses` isn't an array, length mismatches `batch`, or any entry lacks a numeric `id` / defined `result`.
+   */
+  parseBatchResponse({ batch, responses, errorMessage }) {
+    // Gateways can respond with a JSON object (e.g. `{ message }`) instead of a batch array.
+    if (!Array.isArray(responses)) {
+      // Untrusted server text: keep only a short string preview, developer-facing (no `hint`).
+      const message = [responses?.message, responses?.error?.message].find(
+        (value) => typeof value === 'string'
+      )
+      const preview = message ? `: ${message.slice(0, 100)}` : ''
+      throw new Error(`${errorMessage}${preview}`)
+    }
+
+    const isValid = responses.every(
+      (response) => !isNaN(response?.id) && response?.result !== undefined
+    )
+    if (responses.length !== batch.length || !isValid) {
+      throw new Error(errorMessage)
+    }
+
+    // Safe against prototype keys: every `id` is validated numeric by the `isValid` check above.
+    const keyed = Object.fromEntries(
+      responses.map((response) => [`${response.id}`, response.result])
+    )
+    return batch.map((request) => keyed[`${request.id}`])
+  }
 }

package/src/get-historical-balance.js

@@ -0,0 +1,58 @@
+import { TxSet } from '@exodus/models'
+import assert from 'minimalistic-assert'
+
+import { getLatestCanonicalAbsoluteBalanceTx } from './tx-log/clarity-utils/index.js'
+
+const walkBackFromBalance = ({ txLog, deadline, balance }) => {
+  let result = balance
+
+  for (const tx of txLog) {
+    if (new Date(tx.date).getTime() <= deadline) continue
+    if (tx.failed || tx.dropped || tx.pending || tx.data?.replacedBy) continue
+
+    result = result.sub(tx.coinAmount)
+    if (tx.feeAmount?.unitType.equals(tx.coinAmount.unitType)) {
+      result = result.add(tx.feeAmount)
+    }
+  }
+
+  return result.clampLowerZero()
+}
+
+/**
+ * Builds the Ethereum-like balance as of `date`. Anchors on the latest Clarity
+ * absolute-balance snapshot at or before the date, falling back to a walk-back
+ * from the current balance when no snapshot is available.
+ */
+export const getHistoricalBalanceFactory = ({ assetClientInterface, getBalances }) => {
+  assert(assetClientInterface, 'assetClientInterface is required')
+  assert(getBalances, 'getBalances is required')
+
+  return async ({ asset, walletAccount, date }) => {
+    assert(asset, 'asset is required')
+    assert(walletAccount, 'walletAccount is required')
+    assert(date instanceof Date, 'date is required')
+
+    const txLog = await assetClientInterface.getTxLog({ assetName: asset.name, walletAccount })
+    const deadline = date.getTime()
+    const anchor = getLatestCanonicalAbsoluteBalanceTx({ reversedTxLog: txLog.reverse(), deadline })
+
+    if (anchor) {
+      const total = asset.currency.baseUnit(anchor.data.balanceChange.to)
+      return { total, entries: [{ amount: total, date: deadline }] }
+    }
+
+    const accountState = await assetClientInterface.getAccountState({
+      assetName: asset.baseAsset.name,
+      walletAccount,
+    })
+    const confirmedTxLog = TxSet.fromArray([...txLog].filter((tx) => !tx.pending))
+    const balance = getBalances({ asset, accountState, txLog: confirmedTxLog }).spendable
+    const total = walkBackFromBalance({ txLog: confirmedTxLog, deadline, balance })
+
+    return {
+      total,
+      entries: [{ amount: total, date: deadline }],
+    }
+  }
+}

package/src/index.js

@@ -38,6 +38,8 @@ export {
 } 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,

package/src/multicall3/index.js

@@ -22,20 +22,41 @@ const assertSupportedMethod = (method) => {
 const getMulticall3Contract = memoize(() => new SolidityContract(ABI.multicall3))
 
 export class EthLikeRpcRequestAccumulator extends EthLikeServerBase {
-  #requestContext = null
+  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 = []
 
-  #withRequestContext(requestContext, ...args) {
-    assert(this.#requestContext === null)
-    this.#requestContext = requestContext
+  #withRequestParser(functionName, requestParser) {
+    assert(typeof functionName === 'string', 'expected functionName')
+    assert(typeof requestParser === 'function', 'expected requestParser')
 
-    const result = super[requestContext](...args)
+    return (...args) => {
+      assert(!this.#requestParser) // invariant
 
-    this.#requestContext = null
-    return result
+      this.#requestParser = requestParser
+      const result = super[functionName](...args)
+      this.#requestParser = null
+
+      return result
+    }
   }
 
-  _serializeRequest({ context: _, originalRequest }) {
+  _serializeRequest({ originalRequest }) {
     return super.buildRequest(originalRequest)
   }
 
@@ -52,19 +73,49 @@ export class EthLikeRpcRequestAccumulator extends EthLikeServerBase {
       assertValidMulticall3BlockTag(tag)
     }
 
-    const context = this.#requestContext ?? method
-
     void this.#requests.push({
-      context,
       originalRequest,
-      request: this._serializeRequest({ context, originalRequest }),
+      request: this._serializeRequest({ originalRequest }),
+      requestParser: this.#requestParser ?? null,
     })
 
     return this
   }
 
   balanceOfRequest(...args) {
-    return this.#withRequestContext('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)
+  }
+
+  contractStaticCallRequest(contract, functionName, ...args) {
+    assert(contract instanceof SolidityContract, 'expected SolidityContract contract')
+    assert(typeof functionName === 'string', 'expected string functionName')
+
+    const requestParser = ({ result }) => contract[functionName].parse(result)
+
+    return this.#withRequestParser(
+      'ethCallRequest',
+      requestParser
+    )({
+      to: contract.address,
+      data: bufferToHex(contract[functionName].build(...args)),
+    })
   }
 
   length() {
@@ -89,22 +140,11 @@ export class EthLikeRpcRequestAccumulator extends EthLikeServerBase {
       const request = requests[i]
       assert(request)
 
-      const { context, originalRequest } = request
+      const { requestParser: maybeRequestParser, originalRequest } = request
 
-      if (context === 'eth_getBalance') return `0x${BigInt(result).toString(16)}`
-      if (context === 'eth_blockNumber') return `0x${BigInt(result).toString(16)}`
-      if (context === 'balanceOfRequest') {
-        const {
-          params: [{ to: tokenAddress }],
-        } = originalRequest
-        return {
-          confirmed: {
-            [tokenAddress]: BigInt(result).toString(),
-          },
-        }
-      }
+      const requestParser = maybeRequestParser ?? EthLikeRpcRequestAccumulator.REQUEST_PARSER_NOOP
 
-      return result
+      return requestParser({ originalRequest, result })
     })
   }
 }
@@ -121,7 +161,7 @@ export class EthLikeMulticall3RpcRequestAccumulator extends EthLikeRpcRequestAcc
     this.#multicall3Contract = getMulticall3Contract()
   }
 
-  _serializeRequest({ context: _, originalRequest: { method, params } }) {
+  _serializeRequest({ originalRequest: { method, params } }) {
     switch (method) {
       case 'eth_getBalance':
         return {

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')) }
+  }
+}

package/src/simulation/create-simulate-transactions.js

@@ -12,6 +12,7 @@ export const createSimulateTransactions =
     asset,
     origin,
     blockNumber,
+    recipientAddress,
     headers: headersFromParams,
     overrideApiEndpoint,
   }) => {
@@ -56,6 +57,7 @@ export const createSimulateTransactions =
       apiEndpoint: overrideApiEndpoint || apiEndpoint,
       origin,
       blockNumber,
+      recipientAddress,
       simulationResult,
       headers,
     })

package/src/simulation/simulate-transactions-api.js

@@ -3,7 +3,7 @@ import { createCurrency, makeSimulationAPICall } from '@exodus/web3-utils'
 
 import { BLOWFISH_EVM_CHAINS, MAX_INT256_SOLIDITY } from './common.js'
 
-const convertTransactionToApiPayload = (transactions, origin, blockNumber) => {
+const convertTransactionToApiPayload = (transactions, origin, blockNumber, recipientAddress) => {
   const payload = {
     txObjects: transactions.map((transaction) => ({
       from: transaction.from,
@@ -13,9 +13,7 @@ const convertTransactionToApiPayload = (transactions, origin, blockNumber) => {
       gas: transaction.gas,
       gas_price: transaction.gasPrice,
     })),
-    metadata: {
-      origin,
-    },
+    metadata: recipientAddress ? { origin, recipientAddress } : { origin },
     userAccount: transactions[0].from,
   }
 
@@ -156,6 +154,7 @@ export const simulateTransactionsApi = async ({
   apiEndpoint,
   origin,
   blockNumber,
+  recipientAddress,
   simulationResult,
   headers,
   asset,
@@ -174,7 +173,12 @@ export const simulateTransactionsApi = async ({
 
   const userAddress = transactions[0].from
 
-  const payload = convertTransactionToApiPayload(transactions, origin, blockNumber)
+  const payload = convertTransactionToApiPayload(
+    transactions,
+    origin,
+    blockNumber,
+    recipientAddress
+  )
 
   if (!Object.hasOwnProperty.call(BLOWFISH_EVM_CHAINS, asset.name)) {
     return successDefaultResult
@@ -240,24 +244,21 @@ export const simulateTransactionsApi = async ({
     return successDefaultResult
   }
 
-  const userExpectedChanges = Object.keys(expectedStateChanges).reduce((prev, address) => {
-    if (userAddress.toLowerCase() !== address.toLowerCase()) {
-      return prev
-    }
-
-    const result =
-      (Object.prototype.hasOwnProperty.call(expectedStateChanges, address) &&
-        expectedStateChanges[address]) ||
-      []
+  const addressesToProcess = [userAddress.toLowerCase()]
+  if (recipientAddress && recipientAddress.toLowerCase() !== userAddress.toLowerCase()) {
+    addressesToProcess.push(recipientAddress.toLowerCase())
+  }
 
-    return [...prev, ...result]
-  }, [])
+  const relevantExpectedChanges = Object.entries(expectedStateChanges).flatMap(
+    ([address, changes]) =>
+      addressesToProcess.includes(address.toLowerCase()) ? changes ?? [] : []
+  )
 
-  if (!simulationResultHasAssets(userExpectedChanges)) {
+  if (!simulationResultHasAssets(relevantExpectedChanges)) {
     return successDefaultResult
   }
 
-  userExpectedChanges.forEach((expectedChange) => {
+  relevantExpectedChanges.forEach((expectedChange) => {
     handleExpectedBalanceChange(expectedChange, simulationResult, { network })
   })
 

package/src/tx-log/clarity-utils/absolute.js

@@ -50,12 +50,15 @@ const getLatestCanonicalAbsoluteTx = ({
   searchDepthMs = DEFAULT_CANONICAL_ABSOLUTE_TX_SEARCH_DEPTH,
   reversedTxLog,
   fieldName,
+  deadline = Infinity,
 }) => {
   assert(reversedTxLog, 'expected reversedTxLog')
 
   let latest = null
 
   for (const tx of reversedTxLog) {
+    if (+tx.date > deadline) continue
+
     if (latest) {
       const diff = +latest.date - +tx.date
 
@@ -77,10 +80,11 @@ const getLatestCanonicalAbsoluteTx = ({
   return latest
 }
 
-export const getLatestCanonicalAbsoluteBalanceTx = ({ searchDepthMs, reversedTxLog }) =>
+export const getLatestCanonicalAbsoluteBalanceTx = ({ searchDepthMs, reversedTxLog, deadline }) =>
   getLatestCanonicalAbsoluteTx({
     searchDepthMs,
     reversedTxLog,
+    deadline,
     fieldName: ABSOLUTE_FIELD_NAME_BALANCE_CHANGE,
   })