import {z} from 'zod'

export type TransactionScanSupportedChains = 'arbitrum' | 'avalanche' | 'base' | 'base-sepolia' | 'lordchain' | 'lordchain-testnet' | 'metacade' | 'metacade-testnet' | 'bsc' | 'ethereum' | 'optimism' | 'polygon' | 'zksync' | 'zksync-sepolia' | 'zora' | 'linea' | 'blast' | 'scroll' | 'ethereum-sepolia' | 'degen' | 'avalanche-fuji' | 'gnosis' | 'soneium-minato' | 'ronin' | 'apechain' | 'berachain' | 'berachain-bartio' | 'ink' | 'ink-sepolia' | 'abstract' | 'abstract-testnet' | 'soneium' | 'unichain' | 'sei' | 'flow-evm' | 'hyperevm' | 'megaeth' | 'katana' | 'plume' | 'xlayer' | 'monad' | 'monad-testnet' | 'tempo' | 'tempo-testnet' | 'kite-ai' | 'kaia' | 'plasma' | 'mantle' | 'robinhood' | 'arc' | 'flare';

export type TransactionScanChainID = string;

export type ChainParam = TransactionScanSupportedChains | TransactionScanChainID;

export type RoutersEvmModelsValidationOptions = 'validation' | 'simulation' | 'gas_estimation' | 'events';

export type RoutersChainAgnosticModelsRequestAccount = {account_id: string, account_creation_timestamp?: string | undefined, user_age?: number | undefined, user_country_code?: string | undefined, account_addresses?: Array<string> | undefined};

export type RoutersChainAgnosticModelsRequestConnection = {user_agent?: string | undefined, ip_address: unknown, origin?: string | undefined, walletconnect_name?: string | undefined, walletconnect_description?: string | undefined};

export type ScanRequestMetadata = {domain?: string | undefined, non_dapp?: boolean | undefined, account?: RoutersChainAgnosticModelsRequestAccount | undefined, connection?: RoutersChainAgnosticModelsRequestConnection | undefined};

export type RoutersEvmModelsAddressStateOverride = {balance?: string | undefined, nonce?: string | undefined, code?: string | undefined, state?: {[key: string]: string} | undefined, stateDiff?: {[key: string]: string} | undefined, movePrecompileToAddress?: string | undefined};

export type CrossChainBridgeNativeAsset = {type: 'NATIVE', raw_value?: string | undefined};

export type CrossChainBridgeFungibleAsset = {type: 'FUNGIBLE', address: string, raw_value?: string | undefined};

export type CrossChainBridgeNonFungibleAsset = {type: 'NON_FUNGIBLE', address: string, token_id: string};

export type CrossChainBridgeAsset = CrossChainBridgeNativeAsset | CrossChainBridgeFungibleAsset | CrossChainBridgeNonFungibleAsset;

export type CrossChainBridgeHint = {type: 'cross_chain_bridge', destination_address?: string | undefined, destination_chain?: (TransactionScanSupportedChains | string) | undefined, destination_asset?: CrossChainBridgeAsset | undefined};

export type GenericTransactionHint = {type: string};

export type TransactionHint = CrossChainBridgeHint | GenericTransactionHint;

export type TransactionHints = Array<TransactionHint>;

export type RawTransactionRequest = {chain: ChainParam, options?: Array<RoutersEvmModelsValidationOptions> | undefined, metadata: ScanRequestMetadata, block?: (number | string) | undefined, state_override?: {[key: string]: RoutersEvmModelsAddressStateOverride} | undefined, simulate_with_estimated_gas?: boolean | undefined, account_address: string, data: string, transaction_hints?: TransactionHints | undefined};

export type CreateApiV0EvmTransactionRawScanArgs = {body: RawTransactionRequest};

export type CreateApiV0EvmTransactionRawScanOptions = {baseUrl?: string | undefined, APIKey?: string | undefined, fetch?: typeof fetch | undefined};

export const routersEvmResponseTransactionValidationSuccessResultType = z.enum(["Benign", "Warning", "Malicious"]);

export const routersEvmResponseTransactionScanFeatureType = z.enum(["Malicious", "Warning", "Benign", "Info"]);

export const routersEvmResponseTransactionScanFeature = z.object({type: routersEvmResponseTransactionScanFeatureType, feature_id: z.string(), description: z.string(), address: z.string().optional(), metadata: z.object({}).optional()});

export const routersEvmResponseTransactionValidation = z.object({status: z.literal("Success"), result_type: routersEvmResponseTransactionValidationSuccessResultType, description: z.string().optional(), reason: z.string().optional(), classification: z.string().optional(), features: z.array(routersEvmResponseTransactionScanFeature)});

export const routersEvmResponseTransactionValidationError = z.object({status: z.literal("Success"), result_type: z.literal("Error"), description: z.literal(""), reason: z.literal(""), classification: z.literal(""), features: z.array(routersEvmResponseTransactionScanFeature), error: z.string()});

export const routersEvmTokenDetailsERC20TokenDetails = z.object({name: z.string().optional(), symbol: z.string().optional(), address: z.string(), logo_url: z.string().optional(), type: z.literal("ERC20"), decimals: z.number().int()});

export const routersEvmTokenDetailsNONERCTokenDetails = z.object({name: z.string().optional(), symbol: z.string().optional(), address: z.string(), logo_url: z.string().optional(), type: z.literal("NONERC")});

export const routersEvmResponseERC20Diff = z.object({usd_price: z.string().optional(), summary: z.string().optional(), value: z.string().optional(), raw_value: z.string()});

export const routersEvmResponseERC20AddressAssetDiff = z.object({asset_type: z.literal("ERC20"), asset: z.union([routersEvmTokenDetailsERC20TokenDetails, routersEvmTokenDetailsNONERCTokenDetails]), in: z.array(routersEvmResponseERC20Diff), out: z.array(routersEvmResponseERC20Diff)});

export const routersEvmTokenDetailsERC721TokenDetails = z.object({name: z.string().optional(), symbol: z.string().optional(), address: z.string(), logo_url: z.string().optional(), type: z.literal("ERC721")});

export const routersEvmResponseERC721Diff = z.object({usd_price: z.string().optional(), summary: z.string().optional(), token_id: z.string(), arbitrary_collection_token: z.boolean(), logo_url: z.string().optional()});

export const routersEvmResponseERC721AddressAssetDiff = z.object({asset_type: z.literal("ERC721"), asset: z.union([routersEvmTokenDetailsERC721TokenDetails, routersEvmTokenDetailsNONERCTokenDetails]), in: z.array(routersEvmResponseERC721Diff), out: z.array(routersEvmResponseERC721Diff)});

export const routersEvmTokenDetailsERC1155TokenDetails = z.object({name: z.string().optional(), symbol: z.string().optional(), address: z.string(), logo_url: z.string().optional(), type: z.literal("ERC1155")});

export const routersEvmResponseERC1155Diff = z.object({usd_price: z.string().optional(), summary: z.string().optional(), token_id: z.string(), value: z.string(), arbitrary_collection_token: z.boolean(), logo_url: z.string().optional()});

export const routersEvmResponseERC1155AddressAssetDiff = z.object({asset_type: z.literal("ERC1155"), asset: z.union([routersEvmTokenDetailsERC1155TokenDetails, routersEvmTokenDetailsNONERCTokenDetails]), in: z.array(routersEvmResponseERC1155Diff), out: z.array(routersEvmResponseERC1155Diff)});

export const routersEvmTokenDetailsNativeAssetDetails = z.object({type: z.literal("NATIVE"), name: z.string().optional(), symbol: z.string().optional(), chain_name: z.string(), chain_id: z.number().int(), decimals: z.number().int(), logo_url: z.string()});

export const routersEvmResponseNativeDiff = z.object({usd_price: z.string().optional(), summary: z.string().optional(), value: z.string().optional(), raw_value: z.string()});

export const routersEvmResponseNativeAddressAssetDiff = z.object({asset_type: z.literal("NATIVE"), asset: routersEvmTokenDetailsNativeAssetDetails, in: z.array(routersEvmResponseNativeDiff), out: z.array(routersEvmResponseNativeDiff)});

export const routersEvmResponseTransactionAction = z.enum(["mint", "stake", "swap", "native_transfer", "token_transfer", "approval", "set_code_account", "proxy_upgrade", "ownership_change", "bridge", "exchange_batch_withdrawal"]);

export const routersEvmResponseUSDDiff = z.object({in: z.string(), out: z.string(), total: z.string()});

export const routersEvmResponseAssetDiffResponse = z.union([routersEvmResponseERC1155Diff, routersEvmResponseERC721Diff, routersEvmResponseERC20Diff, routersEvmResponseNativeDiff]);

export const routersEvmResponseERC20Exposure = z.object({exposure: z.array(routersEvmResponseAssetDiffResponse), summary: z.string().optional(), approval: z.string(), approval_usd_price: z.string().optional(), expiration: z.string().optional()});

export const routersEvmResponseERC20AddressExposure = z.object({asset_type: z.literal("ERC20"), asset: z.union([routersEvmTokenDetailsERC20TokenDetails, routersEvmTokenDetailsNONERCTokenDetails]), spenders: z.record(z.string(), routersEvmResponseERC20Exposure)});

export const routersEvmResponseERC721Exposure = z.object({exposure: z.array(routersEvmResponseAssetDiffResponse), summary: z.string().optional(), is_approved_for_all: z.boolean()});

export const routersEvmResponseERC721AddressExposure = z.object({asset_type: z.literal("ERC721"), asset: z.union([routersEvmTokenDetailsERC721TokenDetails, routersEvmTokenDetailsNONERCTokenDetails]), spenders: z.record(z.string(), routersEvmResponseERC721Exposure)});

export const routersEvmResponseERC1155Exposure = z.object({exposure: z.array(routersEvmResponseAssetDiffResponse), summary: z.string().optional(), is_approved_for_all: z.boolean()});

export const routersEvmResponseERC1155AddressExposure = z.object({asset_type: z.literal("ERC1155"), asset: z.union([routersEvmTokenDetailsERC1155TokenDetails, routersEvmTokenDetailsNONERCTokenDetails]), spenders: z.record(z.string(), routersEvmResponseERC1155Exposure)});

export const routersEvmResponseAddressDetails = z.object({name_tag: z.string().optional(), contract_name: z.string().optional(), is_eoa: z.boolean().optional()});

export const routersEvmResponseERC20BalanceChanges = z.object({before: routersEvmResponseERC20Diff, after: routersEvmResponseERC20Diff});

export const routersEvmResponseERC20AddressAssetBalanceChangeDiff = z.object({asset_type: z.literal("ERC20"), asset: z.union([routersEvmTokenDetailsERC20TokenDetails, routersEvmTokenDetailsNONERCTokenDetails]), in: z.array(routersEvmResponseERC20Diff), out: z.array(routersEvmResponseERC20Diff), balance_changes: routersEvmResponseERC20BalanceChanges.optional()});

export const routersEvmResponseERC721BalanceChanges = z.object({before: routersEvmResponseERC721Diff, after: routersEvmResponseERC721Diff});

export const routersEvmResponseERC721AddressAssetBalanceChangeDiff = z.object({asset_type: z.literal("ERC721"), asset: z.union([routersEvmTokenDetailsERC721TokenDetails, routersEvmTokenDetailsNONERCTokenDetails]), in: z.array(routersEvmResponseERC721Diff), out: z.array(routersEvmResponseERC721Diff), balance_changes: routersEvmResponseERC721BalanceChanges.optional()});

export const routersEvmResponseERC1155BalanceChanges = z.object({before: routersEvmResponseERC1155Diff, after: routersEvmResponseERC1155Diff});

export const routersEvmResponseERC1155AddressAssetBalanceChangeDiff = z.object({asset_type: z.literal("ERC1155"), asset: z.union([routersEvmTokenDetailsERC1155TokenDetails, routersEvmTokenDetailsNONERCTokenDetails]), in: z.array(routersEvmResponseERC1155Diff), out: z.array(routersEvmResponseERC1155Diff), balance_changes: routersEvmResponseERC1155BalanceChanges.optional()});

export const routersEvmResponseNativeBalanceChanges = z.object({before: routersEvmResponseNativeDiff, after: routersEvmResponseNativeDiff});

export const routersEvmResponseNativeAddressAssetBalanceChangeDiff = z.object({asset_type: z.literal("NATIVE"), asset: routersEvmTokenDetailsNativeAssetDetails, in: z.array(routersEvmResponseNativeDiff), out: z.array(routersEvmResponseNativeDiff), balance_changes: routersEvmResponseNativeBalanceChanges.optional()});

export const routersEvmResponseTraceLabels = z.literal("GAS_FEE");

export const routersEvmResponseERC20AssetTrace = z.object({trace_type: z.literal("AssetTrace"), from_address: z.string(), to_address: z.string(), labels: z.array(z.union([routersEvmResponseTraceLabels, z.string()])).optional(), type: z.literal("ERC20AssetTrace"), asset: z.union([routersEvmTokenDetailsERC20TokenDetails, routersEvmTokenDetailsNONERCTokenDetails]), diff: routersEvmResponseERC20Diff});

export const routersEvmResponseERC721AssetTrace = z.object({trace_type: z.literal("AssetTrace"), from_address: z.string(), to_address: z.string(), labels: z.array(z.union([routersEvmResponseTraceLabels, z.string()])).optional(), type: z.literal("ERC721AssetTrace"), asset: z.union([routersEvmTokenDetailsERC721TokenDetails, routersEvmTokenDetailsNONERCTokenDetails]), diff: routersEvmResponseERC721Diff});

export const routersEvmResponseERC1155AssetTrace = z.object({trace_type: z.literal("AssetTrace"), from_address: z.string(), to_address: z.string(), labels: z.array(z.union([routersEvmResponseTraceLabels, z.string()])).optional(), type: z.literal("ERC1155AssetTrace"), asset: z.union([routersEvmTokenDetailsERC1155TokenDetails, routersEvmTokenDetailsNONERCTokenDetails]), diff: routersEvmResponseERC1155Diff});

export const routersEvmResponseNativeAssetTrace = z.object({trace_type: z.literal("AssetTrace"), from_address: z.string(), to_address: z.string(), labels: z.array(z.union([routersEvmResponseTraceLabels, z.string()])).optional(), type: z.literal("NativeAssetTrace"), asset: routersEvmTokenDetailsNativeAssetDetails, diff: routersEvmResponseNativeDiff});

export const routersEvmResponseFungibleTokenBalance = z.object({raw_value: z.string(), value: z.number().optional(), usd_price: z.number().optional()});

export const routersEvmResponseERC20ExposureTrace = z.object({trace_type: z.literal("ExposureTrace"), owner: z.string(), spender: z.string(), type: z.literal("ERC20ExposureTrace"), exposed: routersEvmResponseFungibleTokenBalance, asset: z.union([routersEvmTokenDetailsERC20TokenDetails, routersEvmTokenDetailsNONERCTokenDetails])});

export const routersEvmResponseNonFungibleTokenBalance = z.object({token_id: z.string(), amount: z.number().int(), usd_price: z.number().optional(), is_mint: z.boolean().optional(), logo_url: z.string().optional()});

export const routersEvmResponseERC721ExposureTrace = z.object({trace_type: z.literal("ExposureTrace"), owner: z.string(), spender: z.string(), type: z.literal("ERC721ExposureTrace"), exposed: routersEvmResponseNonFungibleTokenBalance.optional(), asset: z.union([routersEvmTokenDetailsERC721TokenDetails, routersEvmTokenDetailsNONERCTokenDetails])});

export const routersEvmResponseERC1155ExposureTrace = z.object({trace_type: z.literal("ExposureTrace"), owner: z.string(), spender: z.string(), type: z.literal("ERC1155ExposureTrace"), asset: z.union([routersEvmTokenDetailsERC1155TokenDetails, routersEvmTokenDetailsNONERCTokenDetails])});

export const routersEvmResponseGeneralAssetDiff = z.object({chain: z.string(), address: z.string(), asset_type: z.string().nullable().optional(), asset: z.union([routersEvmTokenDetailsERC20TokenDetails, routersEvmTokenDetailsERC721TokenDetails, routersEvmTokenDetailsERC1155TokenDetails, routersEvmTokenDetailsNONERCTokenDetails, routersEvmTokenDetailsNativeAssetDetails]), diff: z.object({raw_value: z.string(), value: z.string().optional(), usd_price: z.string().optional()})});

export const routersEvmResponseBridgeAssetTrace = z.object({type: z.literal("BridgeAssetTrace"), bridge_type: z.string().nullable().optional(), display_name: z.string().nullable().optional(), logo_url: z.string().nullable().optional(), source: routersEvmResponseGeneralAssetDiff.nullable().optional(), destinations: z.array(routersEvmResponseGeneralAssetDiff).nullable().optional()});

export const routersEvmResponseAccountSummary = z.object({assets_diffs: z.array(z.union([routersEvmResponseERC20AddressAssetBalanceChangeDiff, routersEvmResponseERC721AddressAssetBalanceChangeDiff, routersEvmResponseERC1155AddressAssetBalanceChangeDiff, routersEvmResponseNativeAddressAssetBalanceChangeDiff])), traces: z.array(z.union([routersEvmResponseERC20AssetTrace, routersEvmResponseERC721AssetTrace, routersEvmResponseERC1155AssetTrace, routersEvmResponseNativeAssetTrace, routersEvmResponseERC20ExposureTrace, routersEvmResponseERC721ExposureTrace, routersEvmResponseERC1155ExposureTrace, routersEvmResponseBridgeAssetTrace])), total_usd_diff: routersEvmResponseUSDDiff, exposures: z.array(z.union([routersEvmResponseERC20AddressExposure, routersEvmResponseERC721AddressExposure, routersEvmResponseERC1155AddressExposure])), total_usd_exposure: z.record(z.string(), z.string())});

export const routersEvmResponseCallData = z.object({function_selector: z.string(), function_signature: z.string().optional(), function_declaration: z.string().optional()});

export const routersEvmResponseJsonRPCParams = z.object({from: z.string().optional(), to: z.string().optional(), value: z.string().optional(), data: z.string().optional(), gas: z.string().optional(), gas_price: z.string().optional(), block_tag: z.string().optional(), chain: z.string().optional(), calldata: routersEvmResponseCallData.optional(), user_operation_calldata: routersEvmResponseCallData.optional()});

export const routersEvmResponseAddressChange = z.object({address: z.string()});

export const routersEvmResponseProxyUpgradeManagement = z.object({type: z.literal("PROXY_UPGRADE"), before: routersEvmResponseAddressChange, after: routersEvmResponseAddressChange});

export const routersEvmResponseOwnershipChange = z.object({owners: z.array(z.string())});

export const routersEvmResponseOwnershipChangeManagement = z.object({type: z.literal("OWNERSHIP_CHANGE"), before: routersEvmResponseOwnershipChange, after: routersEvmResponseOwnershipChange});

export const routersEvmResponseModulesChange = z.object({modules: z.array(z.string())});

export const routersEvmResponseModulesChangeManagement = z.object({type: z.literal("MODULE_CHANGE"), before: routersEvmResponseModulesChange, after: routersEvmResponseModulesChange});

export const routersEvmResponseSetCodeAccountManagement = z.object({type: z.literal("SET_CODE_ACCOUNT"), delegated_address: z.string()});

export const routersEvmResponseContractCreation = z.object({type: z.literal("CONTRACT_CREATION"), deployer: z.string()});

export const routersEvmSessionKeysTransferPolicy = z.object({type: z.literal("TRANSFER_POLICY").optional(), asset_details: z.union([routersEvmTokenDetailsNativeAssetDetails, routersEvmTokenDetailsERC20TokenDetails]), value_limit: z.string().optional(), recipient: z.string().optional()});

export const routersEvmSessionKeysCondition = z.enum(["UNCONSTRAINED", "EQUAL", "GREATER", "LESS", "GREATER_OR_EQUAL", "LESS_OR_EQUAL", "NOT_EQUAL"]);

export const routersEvmSessionKeysArgumentCondition = z.object({index: z.number().int(), condition: routersEvmSessionKeysCondition, value: z.string()});

export const routersEvmSessionKeysCallPolicy = z.object({type: z.literal("CALL_POLICY").optional(), to_address: z.string(), method: z.string().optional(), value_limit: z.string().optional(), args: z.array(routersEvmSessionKeysArgumentCondition).optional()});

export const routersEvmSessionKeysGasPolicy = z.object({type: z.literal("GAS_POLICY").optional(), value_limit: z.string()});

export const routersEvmSessionKeysExpirationPolicy = z.object({type: z.literal("EXPIRATION_POLICY").optional(), start_time: z.string().optional(), end_time: z.string().optional()});

export const routersEvmSessionKeysSessionKey = z.object({key: z.string(), signer: z.string(), policies: z.array(z.union([routersEvmSessionKeysTransferPolicy, routersEvmSessionKeysCallPolicy, routersEvmSessionKeysGasPolicy, routersEvmSessionKeysExpirationPolicy]))});

export const routersEvmResponseBalance = z.object({raw_value: z.string(), value: z.string().optional()});

export const routersEvmResponseMissingBalance = z.object({asset: z.union([routersEvmTokenDetailsERC20TokenDetails, routersEvmTokenDetailsNativeAssetDetails]), required_balance: routersEvmResponseBalance, current_balance: routersEvmResponseBalance, missing_balance: routersEvmResponseBalance});

export const routersEvmResponseCrossChainAssetDiffObject = z.object({chain: z.string(), asset_type: z.string(), asset: z.union([routersEvmTokenDetailsERC20TokenDetails, routersEvmTokenDetailsERC721TokenDetails, routersEvmTokenDetailsERC1155TokenDetails, routersEvmTokenDetailsNONERCTokenDetails, routersEvmTokenDetailsNativeAssetDetails]), in: z.array(routersEvmResponseERC20Diff), out: z.array(routersEvmResponseERC20Diff)});

export const routersEvmResponseCrossChainAssetDiffs = z.object({address: z.string(), obj: z.array(routersEvmResponseCrossChainAssetDiffObject)});

export const routersEvmResponseTransactionSimulation = z.object({status: z.literal("Success"), assets_diffs: z.record(z.string(), z.array(z.union([routersEvmResponseERC20AddressAssetDiff, routersEvmResponseERC721AddressAssetDiff, routersEvmResponseERC1155AddressAssetDiff, routersEvmResponseNativeAddressAssetDiff]))), transaction_actions: z.array(z.union([routersEvmResponseTransactionAction, z.string()])), total_usd_diff: z.record(z.string(), routersEvmResponseUSDDiff), exposures: z.record(z.string(), z.array(z.union([routersEvmResponseERC20AddressExposure, routersEvmResponseERC721AddressExposure, routersEvmResponseERC1155AddressExposure]))), total_usd_exposure: z.record(z.string(), z.record(z.string(), z.string())), address_details: z.record(z.string(), routersEvmResponseAddressDetails), account_summary: routersEvmResponseAccountSummary, params: routersEvmResponseJsonRPCParams.optional(), contract_management: z.record(z.string(), z.array(z.union([routersEvmResponseProxyUpgradeManagement, routersEvmResponseOwnershipChangeManagement, routersEvmResponseModulesChangeManagement, routersEvmResponseSetCodeAccountManagement, routersEvmResponseContractCreation]))).optional(), session_key: z.record(z.string(), z.array(routersEvmSessionKeysSessionKey)), missing_balances: z.array(routersEvmResponseMissingBalance).optional(), simulation_run_count: z.number().int().optional(), cross_chain_asset_diffs: z.array(routersEvmResponseCrossChainAssetDiffs).nullable().optional()});

export const routersEvmResponseNativeAsset = z.object({type: z.literal("NATIVE"), details: routersEvmTokenDetailsNativeAssetDetails});

export const routersEvmResponseERC20Asset = z.object({type: z.literal("ERC20"), details: routersEvmTokenDetailsERC20TokenDetails});

export const routersEvmResponseERC721Asset = z.object({type: z.literal("ERC721"), token_id: z.number().int(), details: routersEvmTokenDetailsERC1155TokenDetails});

export const routersEvmResponseERC1155Asset = z.object({type: z.literal("ERC1155"), token_id: z.number().int(), details: routersEvmTokenDetailsERC1155TokenDetails});

export const routersEvmResponseGeneralInsufficientFundsErrorDetails = z.object({code: z.literal("GENERAL_INSUFFICIENT_FUNDS"), category: z.literal("REVERT").optional(), account_address: z.string(), current_balance: z.string().optional(), required_balance: z.string().optional(), asset: z.union([routersEvmResponseNativeAsset, routersEvmResponseERC20Asset, routersEvmResponseERC721Asset, routersEvmResponseERC1155Asset])});

export const routersEvmResponseGeneralInvalidAddressErrorDetails = z.object({code: z.literal("GENERAL_INVALID_ADDRESS"), category: z.literal("INVALID_INPUT").optional(), address: z.string()});

export const routersEvmResponseGenericErrorDetails = z.object({code: z.string(), category: z.string()});

export const routersEvmResponseUnsupportedEIP712MessageErrorDetails = z.object({code: z.literal("UNSUPPORTED_EIP712_MESSAGE"), category: z.literal("INVALID_INPUT").optional(), domain_name: z.string(), message_type: z.string()});

export const routersEvmResponseTransactionSimulationError = z.object({status: z.literal("Error"), error: z.string(), error_details: z.union([routersEvmResponseGeneralInsufficientFundsErrorDetails, routersEvmResponseGeneralInvalidAddressErrorDetails, routersEvmResponseGenericErrorDetails, routersEvmResponseUnsupportedEIP712MessageErrorDetails]).optional(), description: z.string()});

export const routersEvmModelsTransactionScanLogParamInfo = z.object({type: z.string(), value: z.union([z.string(), z.object({}), z.array(z.unknown())]), internalType: z.string().optional(), name: z.string().optional()});

export const routersEvmModelsTransactionScanEvent = z.object({emitter_address: z.string(), emitter_name: z.string().optional(), name: z.string().optional(), params: z.array(routersEvmModelsTransactionScanLogParamInfo).optional(), topics: z.array(z.string()), data: z.string()});

export const routersEvmModelsTransactionScanGasEstimation = z.object({status: z.literal("Success"), used: z.string(), estimate: z.string()});

export const routersEvmModelsTransactionScanGasEstimationError = z.object({status: z.literal("Error"), error: z.string()});

export const routersEvmModelsUserOperationV6GasEstimation = z.object({status: z.literal("Success"), pre_verification_gas_estimate: z.string(), verification_gas_estimate: z.string(), call_gas_estimate: z.string()});

export const routersEvmModelsUserOperationV7GasEstimation = z.object({status: z.literal("Success"), pre_verification_gas_estimate: z.string(), verification_gas_estimate: z.string(), call_gas_estimate: z.string(), paymaster_verification_gas_estimate: z.string()});

export const routersEvmResponseTransactionScanResponse = z.object({validation: z.union([routersEvmResponseTransactionValidation, routersEvmResponseTransactionValidationError]).optional(), simulation: z.union([routersEvmResponseTransactionSimulation, routersEvmResponseTransactionSimulationError]).optional(), events: z.array(routersEvmModelsTransactionScanEvent).optional(), gas_estimation: z.union([routersEvmModelsTransactionScanGasEstimation, routersEvmModelsTransactionScanGasEstimationError]).optional(), user_operation_gas_estimation: z.union([routersEvmModelsUserOperationV6GasEstimation, routersEvmModelsUserOperationV7GasEstimation, routersEvmModelsTransactionScanGasEstimationError]).optional(), features: z.object({}).optional(), block: z.string(), chain: z.string(), account_address: z.string().optional()});

export const validateResponse = async <Output>(
  schema: {
    readonly '~standard': {
      readonly validate: (value: unknown) => ({ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }) | Promise<{ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }>
    }
  },
  value: unknown
): Promise<Output> => {
  const result = await schema['~standard'].validate(value)

  if (result.issues !== undefined) {
    const detail = result.issues
      .map(({ message, path }) =>
        path?.length
          ? `${path.map((segment) => String(typeof segment === 'object' ? segment.key : segment)).join('.')}: ${message}`
          : message
      )
      .join('; ')

    throw new Error(`Response does not match the schema: ${detail}`, { cause: { issues: result.issues } })
  }

  return result.value
};

/**
 * Scan Raw Transaction
 * 
 * POST /v0/evm/transaction-raw/scan
 * 
 * Also accepts auth: ClientID
 */
export const createApiV0EvmTransactionRawScan = async (args: CreateApiV0EvmTransactionRawScanArgs, options?: CreateApiV0EvmTransactionRawScanOptions) => {
const {baseUrl = "https://api.blockaid.io", fetch: fetchFn = fetch, APIKey} = options ?? {}

const query = new URLSearchParams()
const headers = new Headers()
headers.set('content-type', "application/json")
headers.set('accept', "application/json")

if (APIKey !== undefined) headers.set("X-API-Key", APIKey)

const url = `${baseUrl.replace(/\/+$/, '')}/v0/evm/transaction-raw/scan${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "POST", headers, body: JSON.stringify(args.body)})

if (!res.ok) throw new Error(`Request failed with status ${res.status}`, {cause: {status: res.status, body: await res.text()}})

return validateResponse(routersEvmResponseTransactionScanResponse, await res.json())
};