@exodus/web3-ethereum-utils 4.7.5 → 4.7.6

package/lib/createSimulateMessage.d.ts

@@ -1,8 +1,8 @@
 import type { EthSimulateMessageParams } from './types.js';
 import type { MessageSimulationResult } from '@exodus/web3-types';
-export declare const createSimulateMessage: ({ apiEndpoint, headers, }?: {
-    apiEndpoint?: string | undefined;
-    headers?: {
-        'X-Api-Version': string;
-    } | undefined;
-}) => ({ message, url, asset, address, }: EthSimulateMessageParams) => Promise<MessageSimulationResult>;
+type CreateSimulateMessage = (params?: {
+    apiEndpoint?: string;
+    headers?: Record<string, string>;
+}) => (params: EthSimulateMessageParams) => Promise<MessageSimulationResult>;
+export declare const createSimulateMessage: CreateSimulateMessage;
+export {};

package/lib/createSimulateMessage.js

@@ -1,37 +1,3 @@
-import { tryParsingSIWE } from '@exodus/web3-utils';
-import assert from 'minimalistic-assert';
-import { getMessageType } from './simulation/getMessageType.js';
-import { simulateMessage } from './simulation/simulateMessage.js';
-export const createSimulateMessage = ({ apiEndpoint = 'https://simulation.a.exodus.io/simulateMessage', headers = {
-    'X-Api-Version': '2023-06-05',
-}, } = {}) => async ({ message, url, asset, address, }) => {
-    assert(url instanceof URL, "'url' should be an instance of the URL object.");
-    const simulationResult = {
-        baseAssetName: asset.baseAssetName,
-        action: 'NONE',
-    };
-    const messageType = getMessageType(message);
-    if (messageType === 2 /* MessageTypeEnum.Unknown */) {
-        return simulationResult;
-    }
-    if (messageType === 0 /* MessageTypeEnum.RawMessage */) {
-        tryParsingSIWE({
-            address,
-            message,
-            url,
-            simulationResult,
-        });
-    }
-    await simulateMessage({
-        address,
-        message: {
-            message,
-            messageType,
-        },
-        url,
-        apiEndpoint,
-        headers,
-        simulationResult,
-    });
-    return simulationResult;
-};
+// @ts-expect-error @exodus/ethereum-api is a JavaScript package without deep declarations.
+import { createSimulateMessage as createEthereumApiSimulateMessage } from '@exodus/ethereum-api/src/simulation/create-simulate-message.js';
+export const createSimulateMessage = createEthereumApiSimulateMessage;

package/lib/createSimulateTransactions.d.ts

@@ -1,3 +1,5 @@
 import type { EthAggregatedTransactionSimulationResult, EthSimulateTransactionParams } from './types.js';
 import type { CreateSimulateTransactionsParams } from '@exodus/web3-types';
-export declare const createSimulateTransactions: ({ apiEndpoint, headers: headersFromDeps }: Required<CreateSimulateTransactionsParams>) => ({ transactions, asset, origin, blockNumber, headers: headersFromParams, overrideApiEndpoint, }: EthSimulateTransactionParams) => Promise<EthAggregatedTransactionSimulationResult>;
+type CreateSimulateTransactions = (params: Required<CreateSimulateTransactionsParams>) => (params: EthSimulateTransactionParams) => Promise<EthAggregatedTransactionSimulationResult>;
+export declare const createSimulateTransactions: CreateSimulateTransactions;
+export {};

package/lib/createSimulateTransactions.js

@@ -1,95 +1,3 @@
-import { createEmptySimulationResult } from '@exodus/web3-utils';
-import { estimateFee } from './simulation/estimateFee.js';
-import { simulateTransactions } from './simulation/simulateTransactions.js';
-import { tryEstimatingChangesLocally } from './simulation/tryEstimatingChangesLocally.js';
-import { decodeRecipientAddresses, getDisplayDetails, getTxFeeDetails } from './transactions.js';
-export const createSimulateTransactions = ({ apiEndpoint, headers: headersFromDeps }) => async ({ transactions, asset, origin, blockNumber, headers: headersFromParams, overrideApiEndpoint, }) => {
-    const headers = { ...headersFromDeps, ...headersFromParams };
-    const simulationResult = createEmptySimulationResult({
-        asset,
-    });
-    if (transactions.length === 0) {
-        const message = 'No transactions provided. Cannot simulate transaction batch.';
-        simulationResult.warnings.push({ kind: 'INTERNAL_ERROR', severity: 'HIGH', message });
-        simulationResult.metadata.humanReadableError = message;
-        return simulationResult;
-    }
-    // Ensure all transactions share the same "from" address
-    // Added this because simulateTransactions makes this assumption and would give us invalid results if it's not the case
-    // If we need this (which is unlikely) we can remove this check and update simulateTransactions to handle multiple from addresses
-    const firstFrom = transactions[0].from.toLowerCase();
-    const hasMismatchedFrom = transactions.some((tx) => tx.from.toLowerCase() !== firstFrom);
-    if (hasMismatchedFrom) {
-        const message = 'All transactions in a batch must have the same "from" address. Cannot simulate transaction batch.';
-        simulationResult.warnings.push({ kind: 'INTERNAL_ERROR', severity: 'HIGH', message });
-        // add human readable error
-        simulationResult.metadata.humanReadableError = message;
-        return simulationResult;
-    }
-    // Check if ALL transactions have a 'to' address - if any are missing, return early
-    // Transactions are linked, so if one is invalid, the entire batch is invalid
-    const hasInvalidTransaction = transactions.some(tx => !tx.to);
-    if (hasInvalidTransaction) {
-        const message = 'One or more transactions are missing required "to" address. Cannot simulate transaction batch.';
-        simulationResult.warnings.push({ kind: 'INTERNAL_ERROR', severity: 'HIGH', message });
-        simulationResult.metadata.humanReadableError = message;
-        return simulationResult;
-    }
-    // Fees are added only after a successful simulation (remote or local)
-    simulationResult.recipientAddresses = transactions.map((tx) => decodeRecipientAddresses(tx));
-    // Mutates the simulationResult, simulationTransactionInternalResult is only for checking the kind of response
-    const simulationTransactionInternalResult = await simulateTransactions({
-        asset,
-        transactions,
-        apiEndpoint: overrideApiEndpoint || apiEndpoint,
-        origin,
-        blockNumber,
-        simulationResult,
-        headers,
-    });
-    // Blowfish simulation failed, try local simulation
-    if (simulationTransactionInternalResult.kind === 'error') {
-        if (transactions.length > 1) {
-            // For batched transactions, don't attempt local simulation
-            const message = 'Cannot locally simulate batched transactions.';
-            simulationResult.warnings.push({ kind: 'INTERNAL_ERROR', severity: 'HIGH', message });
-            simulationResult.metadata.humanReadableError = message;
-        }
-        else {
-            const transaction = transactions[0];
-            // Local simulation also mutates the simulationResult, so we need to check if it was successful
-            const simulatedLocally = tryEstimatingChangesLocally({
-                asset,
-                simulationResult,
-                transaction,
-            });
-            // If local simulation succeeded, add fee for the (single) transaction now
-            if (simulatedLocally) {
-                simulationResult.metadata.simulatedLocally = true;
-                simulationResult.balanceChanges.willPayFee.push({
-                    balance: estimateFee({ asset, transaction }),
-                    feeDetails: getTxFeeDetails(transaction),
-                });
-            }
-            else {
-                // Local Simulation also failed.
-                const message = 'Balance changes cannot be estimated.';
-                simulationResult.warnings.push({ kind: 'INTERNAL_ERROR', severity: 'HIGH', message });
-                simulationResult.metadata.humanReadableError = message;
-            }
-        }
-        if (simulationTransactionInternalResult.errorMessage) {
-            simulationResult.metadata.humanReadableError = simulationTransactionInternalResult.errorMessage;
-        }
-        return simulationResult;
-    }
-    // Remote simulation succeeded; add fees for all transactions now
-    for (const transaction of transactions) {
-        simulationResult.balanceChanges.willPayFee.push({
-            balance: estimateFee({ asset, transaction }),
-            feeDetails: getTxFeeDetails(transaction),
-        });
-    }
-    simulationResult.displayDetails = getDisplayDetails(simulationResult.balanceChanges.willApprove);
-    return simulationResult;
-};
+// @ts-expect-error @exodus/ethereum-api is a JavaScript package without deep declarations.
+import { createSimulateTransactions as createEthereumApiSimulateTransactions } from '@exodus/ethereum-api/src/simulation/create-simulate-transactions.js';
+export const createSimulateTransactions = createEthereumApiSimulateTransactions;

package/lib/types.d.ts

@@ -1,5 +1,4 @@
-import type { MessageTypeEnum } from './simulation/getMessageType.js';
-import type { AggregatedTransactionSimulationResult, Asset, BN, MessageSimulationResult, SimulateTransactionParams } from '@exodus/web3-types';
+import type { AggregatedTransactionSimulationResult, Asset, BN, SimulateTransactionParams } from '@exodus/web3-types';
 export interface EthTransactionParams {
     chainId: number;
     from: string;
@@ -61,14 +60,3 @@ export interface EthSimulateMessageParams {
     url: URL;
     address: string;
 }
-export interface SimulateMessageParams {
-    address: EthSimulateMessageParams['address'];
-    message: {
-        message: string;
-        messageType: MessageTypeEnum.RawMessage | MessageTypeEnum.TypedData;
-    };
-    url: EthSimulateMessageParams['url'];
-    apiEndpoint: string;
-    headers: Record<string, string>;
-    simulationResult: MessageSimulationResult;
-}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@exodus/web3-ethereum-utils",
   "description": "Web3 Ethereum utils.",
-  "version": "4.7.5",
+  "version": "4.7.6",
   "type": "module",
   "sideEffects": false,
   "module": "lib/index.js",
@@ -35,16 +35,17 @@
     "test": "run -T exodus-test --jest --esbuild"
   },
   "devDependencies": {
-    "@exodus/assets": "^11.9.0",
+    "@exodus/assets": "^11.10.0",
     "@exodus/ethereum-meta": "^2.12.0",
-    "@exodus/web3-types": "1.59.2",
     "lodash": "^4.17.21"
   },
   "dependencies": {
     "@exodus/basic-utils": "^3.0.1",
+    "@exodus/ethereum-api": "^8.76.4",
     "@exodus/ethereum-lib": "^5.20.0",
     "@exodus/ethereumjs": "^1.5.0",
     "@exodus/solidity-contract": "^1.2.1",
+    "@exodus/web3-types": "^1.62.0",
     "@exodus/web3-utils": "^1.50.1",
     "bn.js": "^5.2.0",
     "minimalistic-assert": "^1.0.1"
@@ -54,5 +55,5 @@
     "url": "https://github.com/ExodusMovement/assets/issues?q=is%3Aissue+is%3Aopen+label%3Aweb3-ethereum-utils"
   },
   "homepage": "https://github.com/ExodusMovement/assets/tree/master/web3/web3-ethereum-utils",
-  "gitHead": "38608063e5eafb78384c129e0b24b2da2d3ab238"
+  "gitHead": "6defbed4f39a326cb0c2d5fcdadf3f2abfb83a46"
 }

package/lib/simulation/common.d.ts

@@ -1,10 +0,0 @@
-import BN from 'bn.js';
-interface BlowfishEvmChain {
-    [key: string]: {
-        network: string;
-        chain: string;
-    };
-}
-export declare const BLOWFISH_EVM_CHAINS: BlowfishEvmChain;
-export declare const MAX_INT256_SOLIDITY: BN;
-export {};

package/lib/simulation/common.js

@@ -1,33 +0,0 @@
-import BN from 'bn.js';
-export const BLOWFISH_EVM_CHAINS = {
-    avalanchec: {
-        network: 'avalanche',
-        chain: 'mainnet',
-    },
-    basemainnet: {
-        network: 'base',
-        chain: 'mainnet',
-    },
-    bsc: {
-        network: 'bnb',
-        chain: 'mainnet',
-    },
-    ethereum: {
-        network: 'ethereum',
-        chain: 'mainnet',
-    },
-    ethereumarbone: {
-        network: 'arbitrum',
-        chain: 'one',
-    },
-    matic: {
-        network: 'polygon',
-        chain: 'mainnet',
-    },
-    optimism: {
-        network: 'optimism',
-        chain: 'mainnet',
-    },
-};
-// The maximum signed integer 2\^255 - 1 represented in BN.
-export const MAX_INT256_SOLIDITY = new BN(2).pow(new BN(255)).subn(1);

package/lib/simulation/estimateFee.d.ts

@@ -1,6 +0,0 @@
-import type { EthTransaction } from '../types.js';
-import type { Asset, NumberUnit } from '@exodus/web3-types';
-export declare const estimateFee: ({ asset, transaction, }: {
-    asset: Asset;
-    transaction: EthTransaction;
-}) => NumberUnit;

package/lib/simulation/estimateFee.js

@@ -1,21 +0,0 @@
-/*
- This utility determines a preliminary fee a transaction is going to pay based on
- its "gas", "gasPrice" and "maxFeePerGas" properties.
-
- Note: if EIP-1559 is enabled, a transaction will have the "maxFeePerGas" field. In that case,
- a final gas price will be determined on-chain (the utility uses a maximum possible gas price value).
- If a transaction has only "gasPrice", it can be considered as a final gas price.
- However, a final fee for non-simple transfers is always calculated on-chain once the EVM executes a transaction
- and has the number of gas consumed.
- */
-import { hexToBN } from '@exodus/web3-utils';
-export const estimateFee = ({ asset, transaction, }) => {
-    const gas = hexToBN(transaction.gas);
-    if (transaction.maxFeePerGas) {
-        const maxFeePerGas = hexToBN(transaction.maxFeePerGas);
-        const maximumFee = gas.mul(maxFeePerGas);
-        return asset.currency.baseUnit(maximumFee.toString());
-    }
-    const gasPrice = hexToBN(transaction.gasPrice);
-    return asset.currency.baseUnit(gas.mul(gasPrice).toString());
-};

package/lib/simulation/estimateSimpleTransfer.d.ts

@@ -1,9 +0,0 @@
-import type { EthTransaction } from '../types.js';
-import type { Asset, NumberUnit } from '@exodus/web3-types';
-export declare class NotSimpleTransferError extends Error {
-    constructor(msg: string);
-}
-export declare const estimateSimpleTransfer: ({ asset, transaction, }: {
-    asset: Asset;
-    transaction: EthTransaction;
-}) => NumberUnit | never;

package/lib/simulation/estimateSimpleTransfer.js

@@ -1,22 +0,0 @@
-/*
- This utility determines whether the provided transaction is a simple native token transfer
- and returns the value it's sending if that's true. Throws an error otherwise.
-
- Note: only simple transfers (non-smart contract calls) can be reliably evaluated locally.
- Even empty `data` field transactions ("0x") can cause unexpected state changes if sent to a smart contract
- with a gas limit exceeding 21000 units.
- */
-import { hexToBN } from '@exodus/web3-utils';
-import { isSimpleTransfer } from '../transactions.js';
-export class NotSimpleTransferError extends Error {
-    constructor(msg) {
-        super(msg);
-    }
-}
-export const estimateSimpleTransfer = ({ asset, transaction, }) => {
-    if (!isSimpleTransfer(transaction)) {
-        throw new NotSimpleTransferError('The transaction input should be empty ("0x").');
-    }
-    const txValue = hexToBN(transaction.value || '0x0').toString();
-    return asset.currency.baseUnit(txValue);
-};

package/lib/simulation/getMessageType.d.ts

@@ -1,6 +0,0 @@
-export declare const enum MessageTypeEnum {
-    'RawMessage' = 0,// References to the `eth_sign` RPC method.
-    'TypedData' = 1,// References to the `eth_signTypedData` RPC method.
-    'Unknown' = 2
-}
-export declare const getMessageType: (message: string) => MessageTypeEnum;

package/lib/simulation/getMessageType.js

@@ -1,21 +0,0 @@
-/*
-  This utility figures out if the supplied message is plaint text to be signed or a structured typed data.
-  See for differences:
-  - https://docs.metamask.io/wallet/reference/personal_sign/
-  - https://docs.metamask.io/wallet/reference/eth_signtypeddata_v4/
-
-  The utility does not make any security checks (e.g. schema validation), it's supposed to be used only for choosing
-  a proper payload type for the simulation API.
- */
-export const getMessageType = (message) => {
-    if (typeof message !== 'string') {
-        return 2 /* MessageTypeEnum.Unknown */;
-    }
-    try {
-        JSON.parse(message);
-        return 1 /* MessageTypeEnum.TypedData */;
-    }
-    catch (err) {
-        return 0 /* MessageTypeEnum.RawMessage */;
-    }
-};

package/lib/simulation/simulateMessage.d.ts

@@ -1,7 +0,0 @@
-import type { SimulateMessageParams } from '../types.js';
-import type { MessageSimulationResult, ScanMessageEvm200Response } from '@exodus/web3-types';
-export declare const handleActionResponse: ({ simulationResult, response, }: {
-    simulationResult: MessageSimulationResult;
-    response: ScanMessageEvm200Response;
-}) => void;
-export declare const simulateMessage: ({ address, apiEndpoint, message, url, headers, simulationResult, }: SimulateMessageParams) => Promise<void>;

package/lib/simulation/simulateMessage.js

@@ -1,46 +0,0 @@
-import { makeSimulationAPICall } from '@exodus/web3-utils';
-import { BLOWFISH_EVM_CHAINS } from './common.js';
-const convertToAPIPayload = ({ address, message, url, }) => {
-    const restParameters = {
-        metadata: { origin: url.href },
-        userAccount: address,
-    };
-    if (message.messageType === 1 /* MessageTypeEnum.TypedData */) {
-        const kind = 'SIGN_TYPED_DATA';
-        return {
-            message: {
-                kind,
-                data: JSON.parse(message.message),
-            },
-            ...restParameters,
-        };
-    }
-    const kind = 'SIGN_MESSAGE';
-    return {
-        message: {
-            kind,
-            rawMessage: message.message,
-        },
-        ...restParameters,
-    };
-};
-export const handleActionResponse = ({ simulationResult, response, }) => {
-    if (['BLOCK', 'WARN'].includes(response.action)) {
-        simulationResult.action = response.action;
-    }
-};
-export const simulateMessage = async ({ address, apiEndpoint, message, url, headers, simulationResult, }) => {
-    const { network, chain } = BLOWFISH_EVM_CHAINS[simulationResult.baseAssetName];
-    const payload = convertToAPIPayload({ address, message, url });
-    const response = await makeSimulationAPICall({
-        url: apiEndpoint,
-        chain,
-        network,
-        payload,
-        headers,
-    });
-    if (!response) {
-        return;
-    }
-    handleActionResponse({ simulationResult, response });
-};

package/lib/simulation/simulateTransactions.d.ts

@@ -1,14 +0,0 @@
-import type { EthAggregatedTransactionSimulationResult, EthSimulateTransactionParams } from '../types.js';
-import type { CreateSimulateTransactionsParams, SimulateTransactionsInternalResult } from '@exodus/web3-types';
-type SimulateTransactionParams = Required<Pick<CreateSimulateTransactionsParams, 'apiEndpoint'>> & Required<Pick<EthSimulateTransactionParams, 'asset' | 'transactions' | 'origin'>> & {
-    blockNumber?: EthSimulateTransactionParams['blockNumber'];
-    simulationResult: EthAggregatedTransactionSimulationResult;
-    headers?: Record<string, string>;
-};
-export declare const enum SimulationErrorMessages {
-    'APICallFailed' = 0,
-    'SimulationFailed' = 1,
-    'SimulationNotSupported' = 2
-}
-export declare const simulateTransactions: ({ transactions, apiEndpoint, origin, blockNumber, simulationResult, headers, asset, }: SimulateTransactionParams) => SimulateTransactionsInternalResult<undefined, SimulationErrorMessages>;
-export {};

package/lib/simulation/simulateTransactions.js

@@ -1,225 +0,0 @@
-/*
- This utility makes an API call to a simulation service, parses the response and mutates the supplied "simulationResult" object
- with the according balance changes.
- */
-import { pick } from '@exodus/basic-utils';
-import { createCurrency, makeSimulationAPICall } from '@exodus/web3-utils';
-import { BLOWFISH_EVM_CHAINS, MAX_INT256_SOLIDITY } from './common.js';
-const convertTransactionToApiPayload = (transactions, origin, blockNumber) => {
-    const payload = {
-        txObjects: transactions.map((transaction) => ({
-            from: transaction.from,
-            to: transaction.to,
-            data: transaction.data,
-            value: transaction.value,
-            gas: transaction.gas,
-            gas_price: transaction.gasPrice,
-        })),
-        metadata: {
-            origin,
-        },
-        userAccount: transactions[0].from,
-    };
-    if (blockNumber !== undefined) {
-        payload.blockNumber = blockNumber;
-    }
-    return payload;
-};
-const createBalanceAmount = (amount, { decimals, symbol }) => {
-    const beforeAmount = createCurrency({
-        amount: amount.before,
-        symbol: symbol,
-        denominator: decimals,
-    });
-    const afterAmount = createCurrency({
-        amount: amount.after,
-        symbol: symbol,
-        denominator: decimals,
-    });
-    return beforeAmount.sub(afterAmount);
-};
-const handleExpectedBalanceChange = (expectedBalanceChange, simulationResult, { network }) => {
-    const { willApprove, willSend, willReceive } = simulationResult.balanceChanges;
-    const { data, kind } = expectedBalanceChange.rawInfo;
-    if (kind === 'FARCASTER_CHANGE_RECOVERY_ADDRESS' || kind === 'ERC20_PERMIT') {
-        return;
-    }
-    const { asset } = data;
-    // ERC1155 is a multi-token standard (https://eips.ethereum.org/EIPS/eip-1155) and can be used for NFTs as well.
-    const isNftTransfer = kind === 'ERC721_TRANSFER' ||
-        (kind === 'ERC1155_TRANSFER' && !asset.decimals);
-    const isNftTransferApproval = kind === 'ERC721_APPROVAL' ||
-        (kind === 'ERC721_APPROVAL_FOR_ALL' && !asset.decimals) ||
-        (kind === 'ERC1155_APPROVAL_FOR_ALL' && !asset.decimals);
-    const decimals = isNftTransfer || isNftTransferApproval || !Number.isFinite(asset.decimals) ? 0 : asset.decimals;
-    const asset_ = pick(asset, [
-        'address',
-        'imageUrl',
-        'name',
-        'symbol',
-        'verified',
-    ]);
-    // According to the Blowfish docs, `symbol` and `name` can be null as they are not required by the standard.
-    // Using `NFT` as a fallback ensures a user sees a meaningful UI in that case.
-    let symbol = asset.symbol || asset.name || 'NFT';
-    // TODO: remove this once Blowfish completes their migration from Matic to POL.
-    if (network === 'polygon' && asset.symbol === 'MATIC') {
-        symbol = 'POL';
-    }
-    if (isNftTransfer || isNftTransferApproval) {
-        asset_.imageUrl = data?.metadata?.rawImageUrl;
-    }
-    if (kind === 'ERC20_APPROVAL' ||
-        kind === 'ERC721_APPROVAL_FOR_ALL' ||
-        kind === 'ERC1155_APPROVAL_FOR_ALL' ||
-        kind === 'ERC721_APPROVAL') {
-        const unitsToUse = symbol || asset.name || 'Units.';
-        const approvingBalance = createCurrency({
-            amount: data.amount.after,
-            symbol: unitsToUse,
-            denominator: decimals,
-        });
-        willApprove.push({
-            asset: asset_,
-            spender: data.spender.address,
-            unitName: unitsToUse,
-            balance: approvingBalance,
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore _number exists on NumberUnit, but deprecated
-            isMaxApproval: approvingBalance._number.gte(MAX_INT256_SOLIDITY),
-        });
-        return;
-    }
-    const { amount } = data;
-    const balance = createBalanceAmount(amount, { decimals, symbol });
-    if (balance.isZero) {
-        return;
-    }
-    const balanceChange = {
-        asset: asset_,
-        balance,
-    };
-    if (isNftTransfer || isNftTransferApproval) {
-        const tokenId = data.tokenId;
-        const compositeId = `${asset.address}/${tokenId}`;
-        balanceChange.nft = {
-            id: `${network}:${compositeId}`,
-            compositeId,
-            title: asset.name,
-        };
-    }
-    if (balance.isNegative) {
-        // Convert to non-negative value.
-        balanceChange.balance = balanceChange.balance.negate();
-        willReceive.push(balanceChange);
-    }
-    else {
-        willSend.push(balanceChange);
-    }
-};
-const simulationResultHasAssets = (expectedStateChanges) => {
-    for (const expectedChange of expectedStateChanges) {
-        const { asset } = expectedChange.rawInfo
-            .data;
-        if (!asset) {
-            return false;
-        }
-    }
-    return true;
-};
-export const simulateTransactions = async ({ transactions, apiEndpoint, origin, blockNumber, simulationResult, headers, asset, }) => {
-    const successDefaultResult = {
-        kind: 'success',
-        value: undefined,
-    };
-    if (!BLOWFISH_EVM_CHAINS[asset.name]) {
-        return {
-            kind: 'error',
-            error: 2 /* SimulationErrorMessages.SimulationNotSupported */,
-            errorMessage: 'Simulation is not supported for this asset.',
-        };
-    }
-    //Only one user address is supported
-    //Sending multiple transactions with different from addresses would lead to invalid results
-    const userAddress = transactions[0].from;
-    const payload = convertTransactionToApiPayload(transactions, origin, blockNumber);
-    if (!Object.hasOwnProperty.call(BLOWFISH_EVM_CHAINS, asset.name)) {
-        // ToDo: accept a logger dep and log the error
-        return successDefaultResult;
-    }
-    const { network, chain } = BLOWFISH_EVM_CHAINS[asset.name];
-    const response = await makeSimulationAPICall({
-        url: apiEndpoint,
-        chain,
-        network,
-        payload,
-        headers,
-    });
-    if (!response) {
-        return {
-            kind: 'error',
-            error: 0 /* SimulationErrorMessages.APICallFailed */,
-            errorMessage: 'Simulation API call failed.',
-        };
-    }
-    simulationResult.metadata.simulatedLocally = false;
-    const { expectedStateChanges = {}, error } = response.simulationResults.aggregated;
-    if (error) {
-        // ToDo: accept a logger dep and log the error
-        // ToDo: consider pushing an error to the "warnings" list
-        return {
-            kind: 'error',
-            error: 1 /* SimulationErrorMessages.SimulationFailed */,
-            errorMessage: error?.humanReadableError,
-        };
-    }
-    const { action } = response;
-    if (action === 'BLOCK') {
-        const warning = {
-            kind: 'MALICIOUS_ACTION',
-            severity: 'CRITICAL',
-            // We use a generic default message unless we find a known warning type below
-            // (TODO: add known warning types)
-            message: 'This dApp could be malicious. Do not proceed unless you are certain this is safe.',
-        };
-        simulationResult.warnings.push(warning);
-    }
-    else if (action === 'WARN') {
-        const warning = {
-            kind: 'SUSPICIOUS_ACTION',
-            severity: 'MEDIUM',
-            message: 'This transaction may be suspicious. Proceed with caution.',
-        };
-        simulationResult.warnings.push(warning);
-    }
-    const noExpectedStateChangesDetected = Object.keys(expectedStateChanges).length === 0;
-    // This is a self-send transaction, adding a zero "transfer" so that the UI can display it.
-    if (noExpectedStateChangesDetected) {
-        simulationResult.balanceChanges.willSend.push({
-            balance: createCurrency({
-                amount: 0,
-                symbol: asset.displayTicker,
-                denominator: asset.currency.defaultUnit.power,
-            }),
-        });
-        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]) ||
-            [];
-        return [...prev, ...result];
-    }, []);
-    // Return and log if asset is not present in the expectedStateChanges
-    if (!simulationResultHasAssets(userExpectedChanges)) {
-        // ToDo: accept a logger dep and log the error
-        return successDefaultResult;
-    }
-    userExpectedChanges.forEach((expectedChange) => {
-        handleExpectedBalanceChange(expectedChange, simulationResult, { network });
-    });
-    return successDefaultResult;
-};

package/lib/simulation/tryEstimatingChangesLocally.d.ts

@@ -1,7 +0,0 @@
-import type { EthAggregatedTransactionSimulationResult, EthTransaction } from '../types.js';
-import type { Asset } from '@exodus/web3-types';
-export declare const tryEstimatingChangesLocally: ({ asset, simulationResult, transaction, }: {
-    asset: Asset;
-    simulationResult: EthAggregatedTransactionSimulationResult;
-    transaction: EthTransaction;
-}) => boolean;

package/lib/simulation/tryEstimatingChangesLocally.js

@@ -1,24 +0,0 @@
-import { estimateSimpleTransfer, NotSimpleTransferError, } from './estimateSimpleTransfer.js';
-/*
- Mutates the provided 'simulationResult' adding a 'willSend' entry if the transaction is a simple transfer.
- The function also returns a boolean indicating whether the local simulation was possible (e.g., if any balance changes were made).
- */
-export const tryEstimatingChangesLocally = ({ asset, simulationResult, transaction, }) => {
-    try {
-        const estimatedValue = estimateSimpleTransfer({ asset, transaction });
-        const actualTransferValue = transaction.from.toLowerCase() === transaction.to.toLowerCase()
-            ? asset.currency.ZERO // A self-send does not transfer any funds.
-            : estimatedValue;
-        simulationResult.balanceChanges.willSend.push({
-            balance: actualTransferValue,
-        });
-        return true;
-    }
-    catch (err) {
-        const expectedError = err instanceof NotSimpleTransferError;
-        if (!expectedError) {
-            // ToDo: accept a logger dep and log an error here
-        }
-        return false;
-    }
-};