Skip to content

Instantly share code, notes, and snippets.

@ydm

ydm/Test.sol.md

Last active December 17, 2024 01:10
Show Gist options
  • Save ydm/53e89967986662803ab979d985f61d9a to your computer and use it in GitHub Desktop.
Save ydm/53e89967986662803ab979d985f61d9a to your computer and use it in GitHub Desktop.
Download ZIP
DIagram of forge-std/Test.sol
Raw
Test.sol.md 
---
title: github.com/ydm/mermaider
---
classDiagram
class `CommonBase` {
    <<abstract>>
    -address VM_ADDRESS
    -address CONSOLE
    -address CREATE2_FACTORY
    -address DEFAULT_SENDER
    -address DEFAULT_TEST_CONTRACT
    -address MULTICALL3_ADDRESS
    -uint256 SECP256K1_ORDER
    -uint256 UINT256_MAX
    -contract Vm vm
    -struct StdStorage stdstore
}
`CommonBase` --o `Vm`
class `TestBase` {
    <<abstract>>
}
`TestBase` --|> `CommonBase`
class `ScriptBase` {
    <<abstract>>
    -contract VmSafe vmSafe
}
`ScriptBase` --o `VmSafe`
`ScriptBase` --|> `CommonBase`
class `StdAssertions` {
    <<abstract>>
    -contract Vm vm
    event log()
    event logs()
    event log_address()
    event log_bytes32()
    event log_int()
    event log_uint()
    event log_bytes()
    event log_string()
    event log_named_address(key, val)
    event log_named_bytes32(key, val)
    event log_named_decimal_int(key, val, decimals)
    event log_named_decimal_uint(key, val, decimals)
    event log_named_int(key, val)
    event log_named_uint(key, val)
    event log_named_bytes(key, val)
    event log_named_string(key, val)
    event log_array(val)
    event log_array(val)
    event log_array(val)
    event log_named_array(key, val)
    event log_named_array(key, val)
    event log_named_array(key, val)
    -bool _failed
    +failed()
    #fail()
    #assertTrue(bool)
    #assertTrue(bool,string)
    #assertFalse(bool)
    #assertFalse(bool,string)
    #assertEq(bool,bool)
    #assertEq(bool,bool,string)
    #assertEq(uint256,uint256)
    #assertEq(uint256,uint256,string)
    #assertEqDecimal(uint256,uint256,uint256)
    #assertEqDecimal(uint256,uint256,uint256,string)
    #assertEq(int256,int256)
    #assertEq(int256,int256,string)
    #assertEqDecimal(int256,int256,uint256)
    #assertEqDecimal(int256,int256,uint256,string)
    #assertEq(address,address)
    #assertEq(address,address,string)
    #assertEq(bytes32,bytes32)
    #assertEq(bytes32,bytes32,string)
    #assertEq32(bytes32,bytes32)
    #assertEq32(bytes32,bytes32,string)
    #assertEq(string,string)
    #assertEq(string,string,string)
    #assertEq(bytes,bytes)
    #assertEq(bytes,bytes,string)
    #assertEq(bool[],bool[])
    #assertEq(bool[],bool[],string)
    #assertEq(uint256[],uint256[])
    #assertEq(uint256[],uint256[],string)
    #assertEq(int256[],int256[])
    #assertEq(int256[],int256[],string)
    #assertEq(address[],address[])
    #assertEq(address[],address[],string)
    #assertEq(bytes32[],bytes32[])
    #assertEq(bytes32[],bytes32[],string)
    #assertEq(string[],string[])
    #assertEq(string[],string[],string)
    #assertEq(bytes[],bytes[])
    #assertEq(bytes[],bytes[],string)
    #assertEqUint(uint256,uint256)
    #assertNotEq(bool,bool)
    #assertNotEq(bool,bool,string)
    #assertNotEq(uint256,uint256)
    #assertNotEq(uint256,uint256,string)
    #assertNotEqDecimal(uint256,uint256,uint256)
    #assertNotEqDecimal(uint256,uint256,uint256,string)
    #assertNotEq(int256,int256)
    #assertNotEq(int256,int256,string)
    #assertNotEqDecimal(int256,int256,uint256)
    #assertNotEqDecimal(int256,int256,uint256,string)
    #assertNotEq(address,address)
    #assertNotEq(address,address,string)
    #assertNotEq(bytes32,bytes32)
    #assertNotEq(bytes32,bytes32,string)
    #assertNotEq32(bytes32,bytes32)
    #assertNotEq32(bytes32,bytes32,string)
    #assertNotEq(string,string)
    #assertNotEq(string,string,string)
    #assertNotEq(bytes,bytes)
    #assertNotEq(bytes,bytes,string)
    #assertNotEq(bool[],bool[])
    #assertNotEq(bool[],bool[],string)
    #assertNotEq(uint256[],uint256[])
    #assertNotEq(uint256[],uint256[],string)
    #assertNotEq(int256[],int256[])
    #assertNotEq(int256[],int256[],string)
    #assertNotEq(address[],address[])
    #assertNotEq(address[],address[],string)
    #assertNotEq(bytes32[],bytes32[])
    #assertNotEq(bytes32[],bytes32[],string)
    #assertNotEq(string[],string[])
    #assertNotEq(string[],string[],string)
    #assertNotEq(bytes[],bytes[])
    #assertNotEq(bytes[],bytes[],string)
    #assertLt(uint256,uint256)
    #assertLt(uint256,uint256,string)
    #assertLtDecimal(uint256,uint256,uint256)
    #assertLtDecimal(uint256,uint256,uint256,string)
    #assertLt(int256,int256)
    #assertLt(int256,int256,string)
    #assertLtDecimal(int256,int256,uint256)
    #assertLtDecimal(int256,int256,uint256,string)
    #assertGt(uint256,uint256)
    #assertGt(uint256,uint256,string)
    #assertGtDecimal(uint256,uint256,uint256)
    #assertGtDecimal(uint256,uint256,uint256,string)
    #assertGt(int256,int256)
    #assertGt(int256,int256,string)
    #assertGtDecimal(int256,int256,uint256)
    #assertGtDecimal(int256,int256,uint256,string)
    #assertLe(uint256,uint256)
    #assertLe(uint256,uint256,string)
    #assertLeDecimal(uint256,uint256,uint256)
    #assertLeDecimal(uint256,uint256,uint256,string)
    #assertLe(int256,int256)
    #assertLe(int256,int256,string)
    #assertLeDecimal(int256,int256,uint256)
    #assertLeDecimal(int256,int256,uint256,string)
    #assertGe(uint256,uint256)
    #assertGe(uint256,uint256,string)
    #assertGeDecimal(uint256,uint256,uint256)
    #assertGeDecimal(uint256,uint256,uint256,string)
    #assertGe(int256,int256)
    #assertGe(int256,int256,string)
    #assertGeDecimal(int256,int256,uint256)
    #assertGeDecimal(int256,int256,uint256,string)
    #assertApproxEqAbs(uint256,uint256,uint256)
    #assertApproxEqAbs(uint256,uint256,uint256,string)
    #assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256)
    #assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256,string)
    #assertApproxEqAbs(int256,int256,uint256)
    #assertApproxEqAbs(int256,int256,uint256,string)
    #assertApproxEqAbsDecimal(int256,int256,uint256,uint256)
    #assertApproxEqAbsDecimal(int256,int256,uint256,uint256,string)
    #assertApproxEqRel(uint256,uint256,uint256)
    #assertApproxEqRel(uint256,uint256,uint256,string)
    #assertApproxEqRelDecimal(uint256,uint256,uint256,uint256)
    #assertApproxEqRelDecimal(uint256,uint256,uint256,uint256,string)
    #assertApproxEqRel(int256,int256,uint256)
    #assertApproxEqRel(int256,int256,uint256,string)
    #assertApproxEqRelDecimal(int256,int256,uint256,uint256)
    #assertApproxEqRelDecimal(int256,int256,uint256,uint256,string)
    #checkEq0(bytes,bytes)
    #assertEq0(bytes,bytes)
    #assertEq0(bytes,bytes,string)
    #assertNotEq0(bytes,bytes)
    #assertNotEq0(bytes,bytes,string)
    #assertEqCall(address,bytes,bytes)
    #assertEqCall(address,bytes,address,bytes)
    #assertEqCall(address,bytes,bytes,bool)
    #assertEqCall(address,bytes,address,bytes,bool)
}
`StdAssertions` --o `Vm`
class `StdChains` {
    <<abstract>>
    -contract VmSafe vm
    -bool stdChainsInitialized
    -mapping[string , struct StdChains.Chain] chains
    -mapping[string , string] defaultRpcUrls
    -mapping[uint256 , string] idToAlias
    -bool fallbackToDefaultRpcUrls
    #getChain(string)
    #getChain(uint256)
    #setChain(string,struct StdChains.ChainData)
    #setChain(string,struct StdChains.Chain)
    -_toUpper(string)
    -getChainWithUpdatedRpcUrl(string,struct StdChains.Chain)
    #setFallbackToDefaultRpcUrls(bool)
    -initializeStdChains()
    -setChainWithDefaultRpcUrl(string,struct StdChains.ChainData)
}
`StdChains` --o `VmSafe`
`StdChains` ..> `StdChains.ChainData`
`StdChains` ..> `StdChains.Chain`
class `StdChains.ChainData` {
    <<struct>>
    -string name
    -uint256 chainId
    -string rpcUrl
}
class `StdChains.Chain` {
    <<struct>>
    -string name
    -uint256 chainId
    -string chainAlias
    -string rpcUrl
}
class `StdCheatsSafe` {
    <<abstract>>
    -contract Vm vm
    -uint256 UINT256_MAX
    -bool gasMeteringOff
    event AddressType(Payable, NonPayable, ZeroAddress, Precompile, ForgeAddress)
    #assumeNotBlacklisted(address,address)
    #assumeNoBlacklisted(address,address)
    #assumeAddressIsNot(address,enum StdCheatsSafe.AddressType)
    #assumeAddressIsNot(address,enum StdCheatsSafe.AddressType,enum StdCheatsSafe.AddressType)
    #assumeAddressIsNot(address,enum StdCheatsSafe.AddressType,enum StdCheatsSafe.AddressType,enum StdCheatsSafe.AddressType)
    #assumeAddressIsNot(address,enum StdCheatsSafe.AddressType,enum StdCheatsSafe.AddressType,enum StdCheatsSafe.AddressType,enum StdCheatsSafe.AddressType)
    -_isPayable(address)
    #assumePayable(address)
    #assumeNotPayable(address)
    #assumeNotZeroAddress(address)
    #assumeNotPrecompile(address)
    #assumeNotPrecompile(address,uint256)
    #assumeNotForgeAddress(address)
    #readEIP1559ScriptArtifact(string)
    #rawToConvertedEIPTx1559s(struct StdCheatsSafe.RawTx1559[])
    #rawToConvertedEIPTx1559(struct StdCheatsSafe.RawTx1559)
    #rawToConvertedEIP1559Detail(struct StdCheatsSafe.RawTx1559Detail)
    #readTx1559s(string)
    #readTx1559(string,uint256)
    #readReceipts(string)
    #readReceipt(string,uint256)
    #rawToConvertedReceipts(struct StdCheatsSafe.RawReceipt[])
    #rawToConvertedReceipt(struct StdCheatsSafe.RawReceipt)
    #rawToConvertedReceiptLogs(struct StdCheatsSafe.RawReceiptLog[])
    #deployCode(string,bytes)
    #deployCode(string)
    #deployCode(string,bytes,uint256)
    #deployCode(string,uint256)
    #makeAddrAndKey(string)
    #makeAddr(string)
    #destroyAccount(address,address)
    #makeAccount(string)
    #deriveRememberKey(string,uint32)
    -_bytesToUint(bytes)
    #isFork()
    -_viewChainId()
    -_pureChainId()
}
`StdCheatsSafe` --o `Vm`
`StdCheatsSafe` ..> `StdCheatsSafe.RawTx1559`
`StdCheatsSafe` ..> `StdCheatsSafe.RawTx1559Detail`
`StdCheatsSafe` ..> `StdCheatsSafe.Tx1559`
`StdCheatsSafe` ..> `StdCheatsSafe.Tx1559Detail`
`StdCheatsSafe` ..> `StdCheatsSafe.TxLegacy`
`StdCheatsSafe` ..> `StdCheatsSafe.TxDetailLegacy`
`StdCheatsSafe` ..> `StdCheatsSafe.AccessList`
`StdCheatsSafe` ..> `StdCheatsSafe.RawReceipt`
`StdCheatsSafe` ..> `StdCheatsSafe.Receipt`
`StdCheatsSafe` ..> `StdCheatsSafe.EIP1559ScriptArtifact`
`StdCheatsSafe` ..> `StdCheatsSafe.RawEIP1559ScriptArtifact`
`StdCheatsSafe` ..> `StdCheatsSafe.RawReceiptLog`
`StdCheatsSafe` ..> `StdCheatsSafe.ReceiptLog`
`StdCheatsSafe` ..> `StdCheatsSafe.TxReturn`
`StdCheatsSafe` ..> `StdCheatsSafe.Account`
class `StdCheatsSafe.RawTx1559` {
    <<struct>>
    -string[] arguments
    -address contractAddress
    -string contractName
    -string functionSig
    -bytes32 hash
    -struct StdCheatsSafe.RawTx1559Detail txDetail
    -string opcode
}
class `StdCheatsSafe.RawTx1559Detail` {
    <<struct>>
    -struct StdCheatsSafe.AccessList[] accessList
    -bytes data
    -address from
    -bytes gas
    -bytes nonce
    -address to
    -bytes txType
    -bytes value
}
class `StdCheatsSafe.Tx1559` {
    <<struct>>
    -string[] arguments
    -address contractAddress
    -string contractName
    -string functionSig
    -bytes32 hash
    -struct StdCheatsSafe.Tx1559Detail txDetail
    -string opcode
}
class `StdCheatsSafe.Tx1559Detail` {
    <<struct>>
    -struct StdCheatsSafe.AccessList[] accessList
    -bytes data
    -address from
    -uint256 gas
    -uint256 nonce
    -address to
    -uint256 txType
    -uint256 value
}
class `StdCheatsSafe.TxLegacy` {
    <<struct>>
    -string[] arguments
    -address contractAddress
    -string contractName
    -string functionSig
    -string hash
    -string opcode
    -struct StdCheatsSafe.TxDetailLegacy transaction
}
class `StdCheatsSafe.TxDetailLegacy` {
    <<struct>>
    -struct StdCheatsSafe.AccessList[] accessList
    -uint256 chainId
    -bytes data
    -address from
    -uint256 gas
    -uint256 gasPrice
    -bytes32 hash
    -uint256 nonce
    -bytes1 opcode
    -bytes32 r
    -bytes32 s
    -uint256 txType
    -address to
    -uint8 v
    -uint256 value
}
class `StdCheatsSafe.AccessList` {
    <<struct>>
    -address accessAddress
    -bytes32[] storageKeys
}
class `StdCheatsSafe.RawReceipt` {
    <<struct>>
    -bytes32 blockHash
    -bytes blockNumber
    -address contractAddress
    -bytes cumulativeGasUsed
    -bytes effectiveGasPrice
    -address from
    -bytes gasUsed
    -struct StdCheatsSafe.RawReceiptLog[] logs
    -bytes logsBloom
    -bytes status
    -address to
    -bytes32 transactionHash
    -bytes transactionIndex
}
class `StdCheatsSafe.Receipt` {
    <<struct>>
    -bytes32 blockHash
    -uint256 blockNumber
    -address contractAddress
    -uint256 cumulativeGasUsed
    -uint256 effectiveGasPrice
    -address from
    -uint256 gasUsed
    -struct StdCheatsSafe.ReceiptLog[] logs
    -bytes logsBloom
    -uint256 status
    -address to
    -bytes32 transactionHash
    -uint256 transactionIndex
}
class `StdCheatsSafe.EIP1559ScriptArtifact` {
    <<struct>>
    -string[] libraries
    -string path
    -string[] pending
    -struct StdCheatsSafe.Receipt[] receipts
    -uint256 timestamp
    -struct StdCheatsSafe.Tx1559[] transactions
    -struct StdCheatsSafe.TxReturn[] txReturns
}
class `StdCheatsSafe.RawEIP1559ScriptArtifact` {
    <<struct>>
    -string[] libraries
    -string path
    -string[] pending
    -struct StdCheatsSafe.RawReceipt[] receipts
    -struct StdCheatsSafe.TxReturn[] txReturns
    -uint256 timestamp
    -struct StdCheatsSafe.RawTx1559[] transactions
}
class `StdCheatsSafe.RawReceiptLog` {
    <<struct>>
    -address logAddress
    -bytes32 blockHash
    -bytes blockNumber
    -bytes data
    -bytes logIndex
    -bool removed
    -bytes32[] topics
    -bytes32 transactionHash
    -bytes transactionIndex
    -bytes transactionLogIndex
}
class `StdCheatsSafe.ReceiptLog` {
    <<struct>>
    -address logAddress
    -bytes32 blockHash
    -uint256 blockNumber
    -bytes data
    -uint256 logIndex
    -bytes32[] topics
    -uint256 transactionIndex
    -uint256 transactionLogIndex
    -bool removed
}
class `StdCheatsSafe.TxReturn` {
    <<struct>>
    -string internalType
    -string value
}
class `StdCheatsSafe.Account` {
    <<struct>>
    -address addr
    -uint256 key
}
class `StdCheats` {
    <<abstract>>
    using stdStorage for struct StdStorage
    -struct StdStorage stdstore
    -contract Vm vm
    -address CONSOLE2_ADDRESS
    #skip(uint256)
    #rewind(uint256)
    #hoax(address)
    #hoax(address,uint256)
    #hoax(address,address)
    #hoax(address,address,uint256)
    #startHoax(address)
    #startHoax(address,uint256)
    #startHoax(address,address)
    #startHoax(address,address,uint256)
    #changePrank(address)
    #changePrank(address,address)
    #deal(address,uint256)
    #deal(address,address,uint256)
    #dealERC1155(address,address,uint256,uint256)
    #deal(address,address,uint256,bool)
    #dealERC1155(address,address,uint256,uint256,bool)
    #dealERC721(address,address,uint256)
    #deployCodeTo(string,address)
    #deployCodeTo(string,bytes,address)
    #deployCodeTo(string,bytes,uint256,address)
    -console2_log_StdCheats(string)
}
`StdCheats` --o `Vm`
`StdCheats` --|> `StdCheatsSafe`
`StdCheats` .. `stdStorage`
class `stdError` {
    <<library>>
    +bytes assertionError
    +bytes arithmeticError
    +bytes divisionError
    +bytes enumConversionError
    +bytes encodeStorageError
    +bytes popError
    +bytes indexOOBError
    +bytes memOverflowError
    +bytes zeroVarError
}
class `StdInvariant` {
    <<abstract>>
    -address[] _excludedContracts
    -address[] _excludedSenders
    -address[] _targetedContracts
    -address[] _targetedSenders
    -string[] _excludedArtifacts
    -string[] _targetedArtifacts
    -struct StdInvariant.FuzzArtifactSelector[] _targetedArtifactSelectors
    -struct StdInvariant.FuzzSelector[] _excludedSelectors
    -struct StdInvariant.FuzzSelector[] _targetedSelectors
    -struct StdInvariant.FuzzInterface[] _targetedInterfaces
    #excludeContract(address)
    #excludeSelector(struct StdInvariant.FuzzSelector)
    #excludeSender(address)
    #excludeArtifact(string)
    #targetArtifact(string)
    #targetArtifactSelector(struct StdInvariant.FuzzArtifactSelector)
    #targetContract(address)
    #targetSelector(struct StdInvariant.FuzzSelector)
    #targetSender(address)
    #targetInterface(struct StdInvariant.FuzzInterface)
    +excludeArtifacts()
    +excludeContracts()
    +excludeSelectors()
    +excludeSenders()
    +targetArtifacts()
    +targetArtifactSelectors()
    +targetContracts()
    +targetSelectors()
    +targetSenders()
    +targetInterfaces()
}
`StdInvariant` ..> `StdInvariant.FuzzSelector`
`StdInvariant` ..> `StdInvariant.FuzzArtifactSelector`
`StdInvariant` ..> `StdInvariant.FuzzInterface`
class `StdInvariant.FuzzSelector` {
    <<struct>>
    -address addr
    -bytes4[] selectors
}
class `StdInvariant.FuzzArtifactSelector` {
    <<struct>>
    -string artifact
    -bytes4[] selectors
}
class `StdInvariant.FuzzInterface` {
    <<struct>>
    -address addr
    -string[] artifacts
}
class `stdJson` {
    <<library>>
    -contract VmSafe vm
    #keyExists(string,string)
    #parseRaw(string,string)
    #readUint(string,string)
    #readUintArray(string,string)
    #readInt(string,string)
    #readIntArray(string,string)
    #readBytes32(string,string)
    #readBytes32Array(string,string)
    #readString(string,string)
    #readStringArray(string,string)
    #readAddress(string,string)
    #readAddressArray(string,string)
    #readBool(string,string)
    #readBoolArray(string,string)
    #readBytes(string,string)
    #readBytesArray(string,string)
    #readUintOr(string,string,uint256)
    #readUintArrayOr(string,string,uint256[])
    #readIntOr(string,string,int256)
    #readIntArrayOr(string,string,int256[])
    #readBytes32Or(string,string,bytes32)
    #readBytes32ArrayOr(string,string,bytes32[])
    #readStringOr(string,string,string)
    #readStringArrayOr(string,string,string[])
    #readAddressOr(string,string,address)
    #readAddressArrayOr(string,string,address[])
    #readBoolOr(string,string,bool)
    #readBoolArrayOr(string,string,bool[])
    #readBytesOr(string,string,bytes)
    #readBytesArrayOr(string,string,bytes[])
    #serialize(string,string)
    #serialize(string,string,bool)
    #serialize(string,string,bool[])
    #serialize(string,string,uint256)
    #serialize(string,string,uint256[])
    #serialize(string,string,int256)
    #serialize(string,string,int256[])
    #serialize(string,string,address)
    #serialize(string,string,address[])
    #serialize(string,string,bytes32)
    #serialize(string,string,bytes32[])
    #serialize(string,string,bytes)
    #serialize(string,string,bytes[])
    #serialize(string,string,string)
    #serialize(string,string,string[])
    #write(string,string)
    #write(string,string,string)
}
`stdJson` --o `VmSafe`
class `stdMath` {
    <<library>>
    -int256 INT256_MIN
    #abs(int256)
    #delta(uint256,uint256)
    #delta(int256,int256)
    #percentDelta(uint256,uint256)
    #percentDelta(int256,int256)
}
class `FindData` {
    <<struct>>
    -uint256 slot
    -uint256 offsetLeft
    -uint256 offsetRight
    -bool found
}
class `StdStorage` {
    <<struct>>
    -mapping[address , mapping[bytes4 , mapping[bytes32 , struct FindData]]] finds
    -bytes32[] _keys
    -bytes4 _sig
    -uint256 _depth
    -address _target
    -bytes32 _set
    -bool _enable_packed_slots
    -bytes _calldata
}
class `stdStorageSafe` {
    <<library>>
    event SlotFound(who, fsig, keysHash, slot)
    event WARNING_UninitedSlot(who, slot)
    -contract Vm vm
    -uint256 UINT256_MAX
    #sigs(string)
    #getCallParams(struct StdStorage)
    #callTarget(struct StdStorage)
    #checkSlotMutatesCall(struct StdStorage,bytes32)
    #findOffset(struct StdStorage,bytes32,bool)
    #findOffsets(struct StdStorage,bytes32)
    #find(struct StdStorage)
    #find(struct StdStorage,bool)
    #target(struct StdStorage,address)
    #sig(struct StdStorage,bytes4)
    #sig(struct StdStorage,string)
    #with_calldata(struct StdStorage,bytes)
    #with_key(struct StdStorage,address)
    #with_key(struct StdStorage,uint256)
    #with_key(struct StdStorage,bytes32)
    #enable_packed_slots(struct StdStorage)
    #depth(struct StdStorage,uint256)
    -read(struct StdStorage)
    #read_bytes32(struct StdStorage)
    #read_bool(struct StdStorage)
    #read_address(struct StdStorage)
    #read_uint(struct StdStorage)
    #read_int(struct StdStorage)
    #parent(struct StdStorage)
    #root(struct StdStorage)
    -bytesToBytes32(bytes,uint256)
    -flatten(bytes32[])
    #clear(struct StdStorage)
    #getMaskByOffsets(uint256,uint256)
    #getUpdatedSlotValue(bytes32,uint256,uint256,uint256)
}
`stdStorageSafe` --o `Vm`
class `stdStorage` {
    <<library>>
    -contract Vm vm
    #sigs(string)
    #find(struct StdStorage)
    #find(struct StdStorage,bool)
    #target(struct StdStorage,address)
    #sig(struct StdStorage,bytes4)
    #sig(struct StdStorage,string)
    #with_key(struct StdStorage,address)
    #with_key(struct StdStorage,uint256)
    #with_key(struct StdStorage,bytes32)
    #with_calldata(struct StdStorage,bytes)
    #enable_packed_slots(struct StdStorage)
    #depth(struct StdStorage,uint256)
    #clear(struct StdStorage)
    #checked_write(struct StdStorage,address)
    #checked_write(struct StdStorage,uint256)
    #checked_write_int(struct StdStorage,int256)
    #checked_write(struct StdStorage,bool)
    #checked_write(struct StdStorage,bytes32)
    #read_bytes32(struct StdStorage)
    #read_bool(struct StdStorage)
    #read_address(struct StdStorage)
    #read_uint(struct StdStorage)
    #read_int(struct StdStorage)
    #parent(struct StdStorage)
    #root(struct StdStorage)
}
`stdStorage` --o `Vm`
class `StdStyle` {
    <<library>>
    -contract VmSafe vm
    -string RED
    -string GREEN
    -string YELLOW
    -string BLUE
    -string MAGENTA
    -string CYAN
    -string BOLD
    -string DIM
    -string ITALIC
    -string UNDERLINE
    -string INVERSE
    -string RESET
    -styleConcat(string,string)
    #red(string)
    #red(uint256)
    #red(int256)
    #red(address)
    #red(bool)
    #redBytes(bytes)
    #redBytes32(bytes32)
    #green(string)
    #green(uint256)
    #green(int256)
    #green(address)
    #green(bool)
    #greenBytes(bytes)
    #greenBytes32(bytes32)
    #yellow(string)
    #yellow(uint256)
    #yellow(int256)
    #yellow(address)
    #yellow(bool)
    #yellowBytes(bytes)
    #yellowBytes32(bytes32)
    #blue(string)
    #blue(uint256)
    #blue(int256)
    #blue(address)
    #blue(bool)
    #blueBytes(bytes)
    #blueBytes32(bytes32)
    #magenta(string)
    #magenta(uint256)
    #magenta(int256)
    #magenta(address)
    #magenta(bool)
    #magentaBytes(bytes)
    #magentaBytes32(bytes32)
    #cyan(string)
    #cyan(uint256)
    #cyan(int256)
    #cyan(address)
    #cyan(bool)
    #cyanBytes(bytes)
    #cyanBytes32(bytes32)
    #bold(string)
    #bold(uint256)
    #bold(int256)
    #bold(address)
    #bold(bool)
    #boldBytes(bytes)
    #boldBytes32(bytes32)
    #dim(string)
    #dim(uint256)
    #dim(int256)
    #dim(address)
    #dim(bool)
    #dimBytes(bytes)
    #dimBytes32(bytes32)
    #italic(string)
    #italic(uint256)
    #italic(int256)
    #italic(address)
    #italic(bool)
    #italicBytes(bytes)
    #italicBytes32(bytes32)
    #underline(string)
    #underline(uint256)
    #underline(int256)
    #underline(address)
    #underline(bool)
    #underlineBytes(bytes)
    #underlineBytes32(bytes32)
    #inverse(string)
    #inverse(uint256)
    #inverse(int256)
    #inverse(address)
    #inverse(bool)
    #inverseBytes(bytes)
    #inverseBytes32(bytes32)
}
`StdStyle` --o `VmSafe`
class `stdToml` {
    <<library>>
    -contract VmSafe vm
    #keyExists(string,string)
    #parseRaw(string,string)
    #readUint(string,string)
    #readUintArray(string,string)
    #readInt(string,string)
    #readIntArray(string,string)
    #readBytes32(string,string)
    #readBytes32Array(string,string)
    #readString(string,string)
    #readStringArray(string,string)
    #readAddress(string,string)
    #readAddressArray(string,string)
    #readBool(string,string)
    #readBoolArray(string,string)
    #readBytes(string,string)
    #readBytesArray(string,string)
    #readUintOr(string,string,uint256)
    #readUintArrayOr(string,string,uint256[])
    #readIntOr(string,string,int256)
    #readIntArrayOr(string,string,int256[])
    #readBytes32Or(string,string,bytes32)
    #readBytes32ArrayOr(string,string,bytes32[])
    #readStringOr(string,string,string)
    #readStringArrayOr(string,string,string[])
    #readAddressOr(string,string,address)
    #readAddressArrayOr(string,string,address[])
    #readBoolOr(string,string,bool)
    #readBoolArrayOr(string,string,bool[])
    #readBytesOr(string,string,bytes)
    #readBytesArrayOr(string,string,bytes[])
    #serialize(string,string)
    #serialize(string,string,bool)
    #serialize(string,string,bool[])
    #serialize(string,string,uint256)
    #serialize(string,string,uint256[])
    #serialize(string,string,int256)
    #serialize(string,string,int256[])
    #serialize(string,string,address)
    #serialize(string,string,address[])
    #serialize(string,string,bytes32)
    #serialize(string,string,bytes32[])
    #serialize(string,string,bytes)
    #serialize(string,string,bytes[])
    #serialize(string,string,string)
    #serialize(string,string,string[])
    #write(string,string)
    #write(string,string,string)
}
`stdToml` --o `VmSafe`
class `StdUtils` {
    <<abstract>>
    -contract IMulticall3 multicall
    -contract VmSafe vm
    -address CONSOLE2_ADDRESS
    -uint256 INT256_MIN_ABS
    -uint256 SECP256K1_ORDER
    -uint256 UINT256_MAX
    -address CREATE2_FACTORY
    #_bound(uint256,uint256,uint256)
    #bound(uint256,uint256,uint256)
    #_bound(int256,int256,int256)
    #bound(int256,int256,int256)
    #boundPrivateKey(uint256)
    #bytesToUint(bytes)
    #computeCreateAddress(address,uint256)
    #computeCreate2Address(bytes32,bytes32,address)
    #computeCreate2Address(bytes32,bytes32)
    #deployMockERC20(string,string,uint8)
    #deployMockERC721(string,string)
    #hashInitCode(bytes)
    #hashInitCode(bytes,bytes)
    #getTokenBalances(address,address[])
    -addressFromLast20Bytes(bytes32)
    #_castLogPayloadViewToPure(function (bytes) view)
    #_sendLogPayload(bytes)
    -_sendLogPayloadView(bytes)
    -console2_log_StdUtils(string)
    -console2_log_StdUtils(string,uint256)
    -console2_log_StdUtils(string,string)
}
`StdUtils` --o `IMulticall3`
`StdUtils` --o `VmSafe`
class `Test` {
    <<abstract>>
    +bool IS_TEST
}
`Test` --|> `TestBase`
`Test` --|> `StdAssertions`
`Test` --|> `StdChains`
`Test` --|> `StdCheats`
`Test` --|> `StdInvariant`
`Test` --|> `StdUtils`
class `VmSafe` {
    <<interface>>
    event CallerMode(None, Broadcast, RecurrentBroadcast, Prank, RecurrentPrank)
    event AccountAccessKind(Call, DelegateCall, CallCode, StaticCall, Create, SelfDestruct, Resume, Balance, Extcodesize, Extcodehash, Extcodecopy)
    event ForgeContext(TestGroup, Test, Coverage, Snapshot, ScriptGroup, ScriptDryRun, ScriptBroadcast, ScriptResume, Unknown)
    event BroadcastTxType(Call, Create, Create2)
    +createWallet(string)*
    +createWallet(uint256)*
    +createWallet(uint256,string)*
    +deriveKey(string,uint32)*
    +deriveKey(string,string,uint32)*
    +deriveKey(string,uint32,string)*
    +deriveKey(string,string,uint32,string)*
    +publicKeyP256(uint256)*
    +rememberKey(uint256)*
    +rememberKeys(string,string,uint32)*
    +rememberKeys(string,string,string,uint32)*
    +signCompact(struct VmSafe.Wallet,bytes32)*
    +signCompact(uint256,bytes32)*
    +signCompact(bytes32)*
    +signCompact(address,bytes32)*
    +signP256(uint256,bytes32)*
    +sign(struct VmSafe.Wallet,bytes32)*
    +sign(uint256,bytes32)*
    +sign(bytes32)*
    +sign(address,bytes32)*
    +envAddress(string)*
    +envAddress(string,string)*
    +envBool(string)*
    +envBool(string,string)*
    +envBytes32(string)*
    +envBytes32(string,string)*
    +envBytes(string)*
    +envBytes(string,string)*
    +envExists(string)*
    +envInt(string)*
    +envInt(string,string)*
    +envOr(string,bool)*
    +envOr(string,uint256)*
    +envOr(string,string,address[])*
    +envOr(string,string,bytes32[])*
    +envOr(string,string,string[])*
    +envOr(string,string,bytes[])*
    +envOr(string,int256)*
    +envOr(string,address)*
    +envOr(string,bytes32)*
    +envOr(string,string)*
    +envOr(string,bytes)*
    +envOr(string,string,bool[])*
    +envOr(string,string,uint256[])*
    +envOr(string,string,int256[])*
    +envString(string)*
    +envString(string,string)*
    +envUint(string)*
    +envUint(string,string)*
    +isContext(enum VmSafe.ForgeContext)*
    +setEnv(string,string)*
    +accesses(address)*
    +addr(uint256)*
    +eth_getLogs(uint256,uint256,address,bytes32[])*
    +getBlobBaseFee()*
    +getBlockNumber()*
    +getBlockTimestamp()*
    +getMappingKeyAndParentOf(address,bytes32)*
    +getMappingLength(address,bytes32)*
    +getMappingSlotAt(address,bytes32,uint256)*
    +getNonce(address)*
    +getNonce(struct VmSafe.Wallet)*
    +getRecordedLogs()*
    +lastCallGas()*
    +load(address,bytes32)*
    +pauseGasMetering()*
    +record()*
    +recordLogs()*
    +resetGasMetering()*
    +resumeGasMetering()*
    +rpc(string,string)*
    +rpc(string,string,string)*
    +startDebugTraceRecording()*
    +startMappingRecording()*
    +startStateDiffRecording()*
    +stopAndReturnDebugTraceRecording()*
    +stopAndReturnStateDiff()*
    +stopMappingRecording()*
    +closeFile(string)*
    +copyFile(string,string)*
    +createDir(string,bool)*
    +deployCode(string)*
    +deployCode(string,bytes)*
    +exists(string)*
    +ffi(string[])*
    +fsMetadata(string)*
    +getArtifactPathByCode(bytes)*
    +getArtifactPathByDeployedCode(bytes)*
    +getBroadcast(string,uint64,enum VmSafe.BroadcastTxType)*
    +getBroadcasts(string,uint64,enum VmSafe.BroadcastTxType)*
    +getBroadcasts(string,uint64)*
    +getCode(string)*
    +getDeployedCode(string)*
    +getDeployment(string)*
    +getDeployment(string,uint64)*
    +getDeployments(string,uint64)*
    +isDir(string)*
    +isFile(string)*
    +projectRoot()*
    +prompt(string)*
    +promptAddress(string)*
    +promptSecret(string)*
    +promptSecretUint(string)*
    +promptUint(string)*
    +readDir(string)*
    +readDir(string,uint64)*
    +readDir(string,uint64,bool)*
    +readFile(string)*
    +readFileBinary(string)*
    +readLine(string)*
    +readLink(string)*
    +removeDir(string,bool)*
    +removeFile(string)*
    +tryFfi(string[])*
    +unixTime()*
    +writeFile(string,string)*
    +writeFileBinary(string,bytes)*
    +writeLine(string,string)*
    +keyExistsJson(string,string)*
    +parseJsonAddress(string,string)*
    +parseJsonAddressArray(string,string)*
    +parseJsonBool(string,string)*
    +parseJsonBoolArray(string,string)*
    +parseJsonBytes(string,string)*
    +parseJsonBytes32(string,string)*
    +parseJsonBytes32Array(string,string)*
    +parseJsonBytesArray(string,string)*
    +parseJsonInt(string,string)*
    +parseJsonIntArray(string,string)*
    +parseJsonKeys(string,string)*
    +parseJsonString(string,string)*
    +parseJsonStringArray(string,string)*
    +parseJsonTypeArray(string,string,string)*
    +parseJsonType(string,string)*
    +parseJsonType(string,string,string)*
    +parseJsonUint(string,string)*
    +parseJsonUintArray(string,string)*
    +parseJson(string)*
    +parseJson(string,string)*
    +serializeAddress(string,string,address)*
    +serializeAddress(string,string,address[])*
    +serializeBool(string,string,bool)*
    +serializeBool(string,string,bool[])*
    +serializeBytes32(string,string,bytes32)*
    +serializeBytes32(string,string,bytes32[])*
    +serializeBytes(string,string,bytes)*
    +serializeBytes(string,string,bytes[])*
    +serializeInt(string,string,int256)*
    +serializeInt(string,string,int256[])*
    +serializeJson(string,string)*
    +serializeJsonType(string,bytes)*
    +serializeJsonType(string,string,string,bytes)*
    +serializeString(string,string,string)*
    +serializeString(string,string,string[])*
    +serializeUintToHex(string,string,uint256)*
    +serializeUint(string,string,uint256)*
    +serializeUint(string,string,uint256[])*
    +writeJson(string,string)*
    +writeJson(string,string,string)*
    +keyExists(string,string)*
    +attachDelegation(struct VmSafe.SignedDelegation)*
    +broadcastRawTransaction(bytes)*
    +broadcast()*
    +broadcast(address)*
    +broadcast(uint256)*
    +getWallets()*
    +signAndAttachDelegation(address,uint256)*
    +signDelegation(address,uint256)*
    +startBroadcast()*
    +startBroadcast(address)*
    +startBroadcast(uint256)*
    +stopBroadcast()*
    +contains(string,string)*
    +indexOf(string,string)*
    +parseAddress(string)*
    +parseBool(string)*
    +parseBytes(string)*
    +parseBytes32(string)*
    +parseInt(string)*
    +parseUint(string)*
    +replace(string,string,string)*
    +split(string,string)*
    +toLowercase(string)*
    +toString(address)*
    +toString(bytes)*
    +toString(bytes32)*
    +toString(bool)*
    +toString(uint256)*
    +toString(int256)*
    +toUppercase(string)*
    +trim(string)*
    +assertApproxEqAbs()
    +assertApproxEqAbsDecimal()
    +assertApproxEqRel()
    +assertApproxEqRelDecimal()
    +assertEq()
    +assertEqDecimal()
    +assertFalse()
    +assertGe()
    +assertGeDecimal()
    +assertGt()
    +assertGtDecimal()
    +assertLe()
    +assertLeDecimal()
    +assertLt()
    +assertLtDecimal()
    +assertNotEq()
    +assertNotEqDecimal()
    +assertTrue()
    +assume(bool)*
    +assumeNoRevert()*
    +breakpoint(string)*
    +breakpoint(string,bool)*
    +getFoundryVersion()*
    +rpcUrl(string)*
    +rpcUrlStructs()*
    +rpcUrls()*
    +sleep(uint256)*
    +keyExistsToml(string,string)*
    +parseTomlAddress(string,string)*
    +parseTomlAddressArray(string,string)*
    +parseTomlBool(string,string)*
    +parseTomlBoolArray(string,string)*
    +parseTomlBytes(string,string)*
    +parseTomlBytes32(string,string)*
    +parseTomlBytes32Array(string,string)*
    +parseTomlBytesArray(string,string)*
    +parseTomlInt(string,string)*
    +parseTomlIntArray(string,string)*
    +parseTomlKeys(string,string)*
    +parseTomlString(string,string)*
    +parseTomlStringArray(string,string)*
    +parseTomlTypeArray(string,string,string)*
    +parseTomlType(string,string)*
    +parseTomlType(string,string,string)*
    +parseTomlUint(string,string)*
    +parseTomlUintArray(string,string)*
    +parseToml(string)*
    +parseToml(string,string)*
    +writeToml(string,string)*
    +writeToml(string,string,string)*
    +computeCreate2Address(bytes32,bytes32,address)*
    +computeCreate2Address(bytes32,bytes32)*
    +computeCreateAddress(address,uint256)*
    +copyStorage(address,address)*
    +ensNamehash(string)*
    +getLabel(address)*
    +label(address,string)*
    +pauseTracing()*
    +randomAddress()*
    +randomBool()*
    +randomBytes(uint256)*
    +randomBytes4()*
    +randomBytes8()*
    +randomInt()*
    +randomInt(uint256)*
    +randomUint()*
    +randomUint(uint256,uint256)*
    +randomUint(uint256)*
    +resumeTracing()*
    +setArbitraryStorage(address)*
    +toBase64URL(bytes)*
    +toBase64URL(string)*
    +toBase64(bytes)*
    +toBase64(string)*
}
`VmSafe` ..> `VmSafe.Log`
`VmSafe` ..> `VmSafe.Rpc`
`VmSafe` ..> `VmSafe.EthGetLogs`
`VmSafe` ..> `VmSafe.DirEntry`
`VmSafe` ..> `VmSafe.FsMetadata`
`VmSafe` ..> `VmSafe.Wallet`
`VmSafe` ..> `VmSafe.FfiResult`
`VmSafe` ..> `VmSafe.ChainInfo`
`VmSafe` ..> `VmSafe.AccountAccess`
`VmSafe` ..> `VmSafe.StorageAccess`
`VmSafe` ..> `VmSafe.Gas`
`VmSafe` ..> `VmSafe.DebugStep`
`VmSafe` ..> `VmSafe.BroadcastTxSummary`
`VmSafe` ..> `VmSafe.SignedDelegation`
class `VmSafe.Log` {
    <<struct>>
    -bytes32[] topics
    -bytes data
    -address emitter
}
class `VmSafe.Rpc` {
    <<struct>>
    -string key
    -string url
}
class `VmSafe.EthGetLogs` {
    <<struct>>
    -address emitter
    -bytes32[] topics
    -bytes data
    -bytes32 blockHash
    -uint64 blockNumber
    -bytes32 transactionHash
    -uint64 transactionIndex
    -uint256 logIndex
    -bool removed
}
class `VmSafe.DirEntry` {
    <<struct>>
    -string errorMessage
    -string path
    -uint64 depth
    -bool isDir
    -bool isSymlink
}
class `VmSafe.FsMetadata` {
    <<struct>>
    -bool isDir
    -bool isSymlink
    -uint256 length
    -bool readOnly
    -uint256 modified
    -uint256 accessed
    -uint256 created
}
class `VmSafe.Wallet` {
    <<struct>>
    -address addr
    -uint256 publicKeyX
    -uint256 publicKeyY
    -uint256 privateKey
}
class `VmSafe.FfiResult` {
    <<struct>>
    -int32 exitCode
    -bytes stdout
    -bytes stderr
}
class `VmSafe.ChainInfo` {
    <<struct>>
    -uint256 forkId
    -uint256 chainId
}
class `VmSafe.AccountAccess` {
    <<struct>>
    -struct VmSafe.ChainInfo chainInfo
    -enum VmSafe.AccountAccessKind kind
    -address account
    -address accessor
    -bool initialized
    -uint256 oldBalance
    -uint256 newBalance
    -bytes deployedCode
    -uint256 value
    -bytes data
    -bool reverted
    -struct VmSafe.StorageAccess[] storageAccesses
    -uint64 depth
}
class `VmSafe.StorageAccess` {
    <<struct>>
    -address account
    -bytes32 slot
    -bool isWrite
    -bytes32 previousValue
    -bytes32 newValue
    -bool reverted
}
class `VmSafe.Gas` {
    <<struct>>
    -uint64 gasLimit
    -uint64 gasTotalUsed
    -uint64 gasMemoryUsed
    -int64 gasRefunded
    -uint64 gasRemaining
}
class `VmSafe.DebugStep` {
    <<struct>>
    -uint256[] stack
    -bytes memoryInput
    -uint8 opcode
    -uint64 depth
    -bool isOutOfGas
    -address contractAddr
}
class `VmSafe.BroadcastTxSummary` {
    <<struct>>
    -bytes32 txHash
    -enum VmSafe.BroadcastTxType txType
    -address contractAddress
    -uint64 blockNumber
    -bool success
}
class `VmSafe.SignedDelegation` {
    <<struct>>
    -uint8 v
    -bytes32 r
    -bytes32 s
    -uint64 nonce
    -address implementation
}
class `Vm` {
    <<interface>>
    +activeFork()*
    +allowCheatcodes(address)*
    +blobBaseFee(uint256)*
    +blobhashes(bytes32[])*
    +chainId(uint256)*
    +clearMockedCalls()*
    +cloneAccount(address,address)*
    +coinbase(address)*
    +createFork(string)*
    +createFork(string,uint256)*
    +createFork(string,bytes32)*
    +createSelectFork(string)*
    +createSelectFork(string,uint256)*
    +createSelectFork(string,bytes32)*
    +deal(address,uint256)*
    +deleteStateSnapshot(uint256)*
    +deleteStateSnapshots()*
    +difficulty(uint256)*
    +dumpState(string)*
    +etch(address,bytes)*
    +fee(uint256)*
    +getBlobhashes()*
    +isPersistent(address)*
    +loadAllocs(string)*
    +makePersistent(address)*
    +makePersistent(address,address)*
    +makePersistent(address,address,address)*
    +makePersistent(address[])*
    +mockCallRevert(address,bytes,bytes)*
    +mockCallRevert(address,uint256,bytes,bytes)*
    +mockCallRevert(address,bytes4,bytes)*
    +mockCallRevert(address,uint256,bytes4,bytes)*
    +mockCall(address,bytes,bytes)*
    +mockCall(address,uint256,bytes,bytes)*
    +mockCall(address,bytes4,bytes)*
    +mockCall(address,uint256,bytes4,bytes)*
    +mockCalls(address,bytes,bytes[])*
    +mockCalls(address,uint256,bytes,bytes[])*
    +mockFunction(address,address,bytes)*
    +prank(address)*
    +prank(address,address)*
    +prank(address,bool)*
    +prank(address,address,bool)*
    +prevrandao(bytes32)*
    +prevrandao(uint256)*
    +readCallers()*
    +resetNonce(address)*
    +revertToState(uint256)*
    +revertToStateAndDelete(uint256)*
    +revokePersistent(address)*
    +revokePersistent(address[])*
    +roll(uint256)*
    +rollFork(uint256)*
    +rollFork(bytes32)*
    +rollFork(uint256,uint256)*
    +rollFork(uint256,bytes32)*
    +selectFork(uint256)*
    +setBlockhash(uint256,bytes32)*
    +setNonce(address,uint64)*
    +setNonceUnsafe(address,uint64)*
    +snapshotGasLastCall(string)*
    +snapshotGasLastCall(string,string)*
    +snapshotState()*
    +snapshotValue(string,uint256)*
    +snapshotValue(string,string,uint256)*
    +startPrank(address)*
    +startPrank(address,address)*
    +startPrank(address,bool)*
    +startPrank(address,address,bool)*
    +startSnapshotGas(string)*
    +startSnapshotGas(string,string)*
    +stopPrank()*
    +stopSnapshotGas()*
    +stopSnapshotGas(string)*
    +stopSnapshotGas(string,string)*
    +store(address,bytes32,bytes32)*
    +transact(bytes32)*
    +transact(uint256,bytes32)*
    +txGasPrice(uint256)*
    +warp(uint256)*
    +deleteSnapshot(uint256)*
    +deleteSnapshots()*
    +revertToAndDelete(uint256)*
    +revertTo(uint256)*
    +snapshot()*
    +expectCallMinGas(address,uint256,uint64,bytes)*
    +expectCallMinGas(address,uint256,uint64,bytes,uint64)*
    +expectCall(address,bytes)*
    +expectCall(address,bytes,uint64)*
    +expectCall(address,uint256,bytes)*
    +expectCall(address,uint256,bytes,uint64)*
    +expectCall(address,uint256,uint64,bytes)*
    +expectCall(address,uint256,uint64,bytes,uint64)*
    +expectEmitAnonymous(bool,bool,bool,bool,bool)*
    +expectEmitAnonymous(bool,bool,bool,bool,bool,address)*
    +expectEmitAnonymous()*
    +expectEmitAnonymous(address)*
    +expectEmit(bool,bool,bool,bool)*
    +expectEmit(bool,bool,bool,bool,address)*
    +expectEmit()*
    +expectEmit(address)*
    +expectPartialRevert(bytes4)*
    +expectPartialRevert(bytes4,address)*
    +expectRevert()*
    +expectRevert(bytes4)*
    +expectRevert(bytes)*
    +expectRevert(address)*
    +expectRevert(bytes4,address)*
    +expectRevert(bytes,address)*
    +expectRevert(uint64)*
    +expectRevert(bytes4,uint64)*
    +expectRevert(bytes,uint64)*
    +expectRevert(address,uint64)*
    +expectRevert(bytes4,address,uint64)*
    +expectRevert(bytes,address,uint64)*
    +expectSafeMemory(uint64,uint64)*
    +expectSafeMemoryCall(uint64,uint64)*
    +skip(bool)*
    +skip(bool,string)*
    +stopExpectSafeMemory()*
}
`Vm` ..|> `VmSafe`
class `console` {
    <<library>>
    -address CONSOLE_ADDRESS
    #_sendLogPayloadImplementation(bytes)
    #_castToPure(function (bytes) view)
    #_sendLogPayload(bytes)
}
class `IERC165` {
    <<interface>>
    +supportsInterface(bytes4)*
}
class `IERC20` {
    <<interface>>
    event Transfer(from, to, value)
    event Approval(owner, spender, value)
    +totalSupply()*
    +balanceOf(address)*
    +transfer(address,uint256)*
    +allowance(address,address)*
    +approve(address,uint256)*
    +transferFrom(address,address,uint256)*
    +name()*
    +symbol()*
    +decimals()*
}
class `IERC721` {
    <<interface>>
    event Transfer(_from, _to, _tokenId)
    event Approval(_owner, _approved, _tokenId)
    event ApprovalForAll(_owner, _operator, _approved)
    +balanceOf(address)*
    +ownerOf(uint256)*
    +safeTransferFrom(address,address,uint256,bytes)*
    +safeTransferFrom(address,address,uint256)*
    +transferFrom(address,address,uint256)*
    +approve(address,uint256)*
    +setApprovalForAll(address,bool)*
    +getApproved(uint256)*
    +isApprovedForAll(address,address)*
}
`IERC721` ..|> `IERC165`
class `IERC721TokenReceiver` {
    <<interface>>
    +onERC721Received(address,address,uint256,bytes)*
}
class `IERC721Metadata` {
    <<interface>>
    +name()*
    +symbol()*
    +tokenURI(uint256)*
}
`IERC721Metadata` ..|> `IERC721`
class `IERC721Enumerable` {
    <<interface>>
    +totalSupply()*
    +tokenByIndex(uint256)*
    +tokenOfOwnerByIndex(address,uint256)*
}
`IERC721Enumerable` ..|> `IERC721`
class `IMulticall3` {
    <<interface>>
    +aggregate(struct IMulticall3.Call[])*
    +aggregate3(struct IMulticall3.Call3[])*
    +aggregate3Value(struct IMulticall3.Call3Value[])*
    +blockAndAggregate(struct IMulticall3.Call[])*
    +getBasefee()*
    +getBlockHash(uint256)*
    +getBlockNumber()*
    +getChainId()*
    +getCurrentBlockCoinbase()*
    +getCurrentBlockDifficulty()*
    +getCurrentBlockGasLimit()*
    +getCurrentBlockTimestamp()*
    +getEthBalance(address)*
    +getLastBlockHash()*
    +tryAggregate(bool,struct IMulticall3.Call[])*
    +tryBlockAndAggregate(bool,struct IMulticall3.Call[])*
}
`IMulticall3` ..> `IMulticall3.Call`
`IMulticall3` ..> `IMulticall3.Call3`
`IMulticall3` ..> `IMulticall3.Call3Value`
`IMulticall3` ..> `IMulticall3.Result`
class `IMulticall3.Call` {
    <<struct>>
    -address target
    -bytes callData
}
class `IMulticall3.Call3` {
    <<struct>>
    -address target
    -bool allowFailure
    -bytes callData
}
class `IMulticall3.Call3Value` {
    <<struct>>
    -address target
    -bool allowFailure
    -uint256 value
    -bytes callData
}
class `IMulticall3.Result` {
    <<struct>>
    -bool success
    -bytes returnData
}
class `MockERC20` {
    -string _name
    -string _symbol
    -uint8 _decimals
    +name()
    +symbol()
    +decimals()
    -uint256 _totalSupply
    -mapping[address , uint256] _balanceOf
    -mapping[address , mapping[address , uint256]] _allowance
    +totalSupply()
    +balanceOf(address)
    +allowance(address,address)
    -uint256 INITIAL_CHAIN_ID
    -bytes32 INITIAL_DOMAIN_SEPARATOR
    +mapping[address , uint256] nonces
    -bool initialized
    +initialize(string,string,uint8)
    +approve(address,uint256)
    +transfer(address,uint256)
    +transferFrom(address,address,uint256)
    +permit(address,address,uint256,uint256,uint8,bytes32,bytes32)
    +DOMAIN_SEPARATOR()
    #computeDomainSeparator()
    #_mint(address,uint256)
    #_burn(address,uint256)
    #_add(uint256,uint256)
    #_sub(uint256,uint256)
    -_viewChainId()
    -_pureChainId()
}
`MockERC20` ..|> `IERC20`
class `MockERC721` {
    -string _name
    -string _symbol
    +name()
    +symbol()
    +tokenURI(uint256)
    -mapping[uint256 , address] _ownerOf
    -mapping[address , uint256] _balanceOf
    +ownerOf(uint256)
    +balanceOf(address)
    -mapping[uint256 , address] _getApproved
    -mapping[address , mapping[address , bool]] _isApprovedForAll
    +getApproved(uint256)
    +isApprovedForAll(address,address)
    -bool initialized
    +initialize(string,string)
    +approve(address,uint256)
    +setApprovalForAll(address,bool)
    +transferFrom(address,address,uint256)
    +safeTransferFrom(address,address,uint256)
    +safeTransferFrom(address,address,uint256,bytes)
    +supportsInterface(bytes4)
    #_mint(address,uint256)
    #_burn(uint256)
    #_safeMint(address,uint256)
    #_safeMint(address,uint256,bytes)
    -_isContract(address)
}
`MockERC721` ..|> `IERC721Metadata`
class `safeconsole` {
    <<library>>
    -uint256 CONSOLE_ADDR
    -_sendLogPayload(uint256,uint256)
    -_sendLogPayloadView(uint256,uint256)
    -_memcopy(uint256,uint256,uint256)
    -_memcopyView(uint256,uint256,uint256)
}
Loading
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment