Overview
ETH Balance
ETH Value
$0.00Token Holdings
Could not find any matches!
- ERC-20 Tokens (4)15,000 WLD [ WWW.GET-WLD.ORG ] Visit to claim rewardERC-20: ! (WLD [ ...)43,767 BRC-20.WSERC-20: ! BRC-20.... (BRC-20...)1 claim rewards on debridgether.comERC-20: Acces deb... (claim ...)43,767 TokenERC-20 TOKEN*[Spam]NFT Tokens (25)Events+ $50 000 (BONUS-ETH.NET)ERC-1155Airdrop+$50 000 (BONUS-ETH.NET) 🎁ERC-1155Airdrop$50 000 FOR FREEERC-1155hurry Up!$5O OOO FOR FREEERC-1155EventEthereumERC-1155EventEthereumERC-1155EthereumEthereumERC-1155EventEventERC-1155EventEventERC-1155$FLOKIFLOKI AIRDROP AT floki-crypto.onlineERC-1155ERC-1155 TOKEN*[Spam]ERC-1155 TOKEN*[Spam]ERC-1155 TOKEN*[Spam]ERC-1155 TOKEN*[Spam]ERC-1155 TOKEN*[Spam]ERC-1155 TOKEN*[Spam]
More Info
Private Name Tags
ContractCreator
Multichain Info
1 address found viaLatest 25 from a total of 15,752 transactions
Transaction Hash MethodBlockFromToBulk Transfer 129027614 2024-12-08 10:33:25 2 hrs ago 1733654005 IN 0 ETH$0.00 0.00000016232 0.00011033 Bulk Transfer 129027259 2024-12-08 10:21:35 2 hrs ago 1733653295 IN 0 ETH$0.00 0.000000184881 0.00011147 Bulk Transfer 129023148 2024-12-08 8:04:33 4 hrs ago 1733645073 IN 0 ETH$0.00 0.000001197679 0.00100095 Bulk Transfer 129023084 2024-12-08 8:02:25 4 hrs ago 1733644945 IN 0 ETH$0.00 0.000001731825 0.00100083 Bulk Transfer 129023015 2024-12-08 8:00:07 4 hrs ago 1733644807 IN 0 ETH$0.00 0.00000069006 0.00100073 Bulk Transfer 129022953 2024-12-08 7:58:03 4 hrs ago 1733644683 IN 0 ETH$0.00 0.000001200369 0.0010007 Bulk Transfer 129022884 2024-12-08 7:55:45 4 hrs ago 1733644545 IN 0 ETH$0.00 0.000000681915 0.0010007 Bulk Transfer 129022822 2024-12-08 7:53:41 4 hrs ago 1733644421 IN 0 ETH$0.00 0.00000119457 0.00100068 Bulk Transfer 129022717 2024-12-08 7:50:11 4 hrs ago 1733644211 IN 0 ETH$0.00 0.000001201037 0.00100068 Bulk Transfer 129022643 2024-12-08 7:47:43 4 hrs ago 1733644063 IN 0 ETH$0.00 0.000001198194 0.00100068 Bulk Transfer 129022536 2024-12-08 7:44:09 4 hrs ago 1733643849 IN 0 ETH$0.00 0.000001053342 0.00100068 Bulk Transfer 129022473 2024-12-08 7:42:03 4 hrs ago 1733643723 IN 0 ETH$0.00 0.000001716966 0.00100068 Bulk Transfer 129022387 2024-12-08 7:39:11 5 hrs ago 1733643551 IN 0 ETH$0.00 0.000001195343 0.00100068 Bulk Transfer 129022237 2024-12-08 7:34:11 5 hrs ago 1733643251 IN 0 ETH$0.00 0.000001201656 0.00100068 Bulk Transfer 129011785 2024-12-08 1:45:47 10 hrs ago 1733622347 IN 0 ETH$0.00 0.000000768808 0.00010639 Bulk Transfer 129010653 2024-12-08 1:08:03 11 hrs ago 1733620083 IN 0 ETH$0.00 0.000000219073 0.00010777 Bulk Transfer 129008818 2024-12-08 0:06:53 12 hrs ago 1733616413 IN 0 ETH$0.00 0.00000082032 0.00010089 Bulk Transfer 129008727 2024-12-08 0:03:51 12 hrs ago 1733616231 IN 0 ETH$0.00 0.000000608339 0.00010078 Bulk Transfer 129008661 2024-12-08 0:01:39 12 hrs ago 1733616099 IN 0 ETH$0.00 0.000000567964 0.0001007 Bulk Transfer 129008566 2024-12-07 23:58:29 12 hrs ago 1733615909 IN 0 ETH$0.00 0.000000506018 0.0001006 Bulk Transfer 129008511 2024-12-07 23:56:39 12 hrs ago 1733615799 IN 0 ETH$0.00 0.000000543222 0.00010057 Bulk Transfer 129008465 2024-12-07 23:55:07 12 hrs ago 1733615707 IN 0 ETH$0.00 0.000000509754 0.00010055 Bulk Transfer 129008406 2024-12-07 23:53:09 12 hrs ago 1733615589 IN 0 ETH$0.00 0.000000557596 0.00010053 Bulk Transfer 129008346 2024-12-07 23:51:09 12 hrs ago 1733615469 IN 0 ETH$0.00 0.000000654738 0.00010053 Bulk Transfer 129000811 2024-12-07 19:39:59 17 hrs ago 1733600399 IN 0 ETH$0.00 0.000003391643 0.00010047 Latest 25 internal transactions (View All)
Advanced mode:Parent Transaction Hash Block From To 107551360 2023-07-30 7:18:17 497 days ago 1690701497 0 ETH$0.00 107546110 2023-07-30 4:23:17 497 days ago 1690690997 0 ETH$0.00 107542103 2023-07-30 2:09:43 497 days ago 1690682983 0 ETH$0.00 107541986 2023-07-30 2:05:49 497 days ago 1690682749 0 ETH$0.00 107521636 2023-07-29 14:47:29 497 days ago 1690642049 0 ETH$0.00 107514671 2023-07-29 10:55:19 498 days ago 1690628119 0 ETH$0.00 107511324 2023-07-29 9:03:45 498 days ago 1690621425 0 ETH$0.00 107510333 2023-07-29 8:30:43 498 days ago 1690619443 0 ETH$0.00 107499953 2023-07-29 2:44:43 498 days ago 1690598683 0 ETH$0.00 107498438 2023-07-29 1:54:13 498 days ago 1690595653 0 ETH$0.00 107498298 2023-07-29 1:49:33 498 days ago 1690595373 0 ETH$0.00 107498065 2023-07-29 1:41:47 498 days ago 1690594907 0 ETH$0.00 107498018 2023-07-29 1:40:13 498 days ago 1690594813 0 ETH$0.00 107497887 2023-07-29 1:35:51 498 days ago 1690594551 0 ETH$0.00 107497731 2023-07-29 1:30:39 498 days ago 1690594239 0 ETH$0.00 107479021 2023-07-28 15:06:59 498 days ago 1690556819 0 ETH$0.00 107477172 2023-07-28 14:05:21 498 days ago 1690553121 0 ETH$0.00 107470202 2023-07-28 10:13:01 499 days ago 1690539181 0 ETH$0.00 107461106 2023-07-28 5:09:49 499 days ago 1690520989 0 ETH$0.00 107450618 2023-07-27 23:20:13 499 days ago 1690500013 0 ETH$0.00 107450385 2023-07-27 23:12:27 499 days ago 1690499547 0 ETH$0.00 107450102 2023-07-27 23:03:01 499 days ago 1690498981 0 ETH$0.00 107449017 2023-07-27 22:26:51 499 days ago 1690496811 0 ETH$0.00 107448182 2023-07-27 21:59:01 499 days ago 1690495141 0 ETH$0.00 107429201 2023-07-27 11:26:19 500 days ago 1690457179 0 ETH$0.00 Loading...LoadingContract Name:TransferHelper
Compiler Versionv0.8.16+commit.07a7930e
Optimization Enabled:Yes with 1000000 runs
Other Settings:default evmVersionContract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; import { IERC721Receiver } from "../interfaces/IERC721Receiver.sol"; import "./TransferHelperStructs.sol"; import { ConduitInterface } from "../interfaces/ConduitInterface.sol"; import { ConduitControllerInterface } from "../interfaces/ConduitControllerInterface.sol"; import { Conduit } from "../conduit/Conduit.sol"; import { ConduitTransfer } from "../conduit/lib/ConduitStructs.sol"; import { TransferHelperInterface } from "../interfaces/TransferHelperInterface.sol"; import { TransferHelperErrors } from "../interfaces/TransferHelperErrors.sol"; /** * @title TransferHelper * @author stephankmin, stuckinaboot, ryanio * @notice TransferHelper is a utility contract for transferring * ERC20/ERC721/ERC1155 items in bulk to specific recipients. */ contract TransferHelper is TransferHelperInterface, TransferHelperErrors { // Allow for interaction with the conduit controller. ConduitControllerInterface internal immutable _CONDUIT_CONTROLLER; // Set conduit creation code and runtime code hashes as immutable arguments. bytes32 internal immutable _CONDUIT_CREATION_CODE_HASH; bytes32 internal immutable _CONDUIT_RUNTIME_CODE_HASH; /** * @dev Set the supplied conduit controller and retrieve its * conduit creation code hash. * * * @param conduitController A contract that deploys conduits, or proxies * that may optionally be used to transfer approved * ERC20/721/1155 tokens. */ constructor(address conduitController) { // Get the conduit creation code and runtime code hashes from the // supplied conduit controller and set them as an immutable. ConduitControllerInterface controller = ConduitControllerInterface( conduitController ); (_CONDUIT_CREATION_CODE_HASH, _CONDUIT_RUNTIME_CODE_HASH) = controller .getConduitCodeHashes(); // Set the supplied conduit controller as an immutable. _CONDUIT_CONTROLLER = controller; } /** * @notice Transfer multiple ERC20/ERC721/ERC1155 items to * specified recipients. * * @param items The items to transfer to an intended recipient. * @param conduitKey An optional conduit key referring to a conduit through * which the bulk transfer should occur. * * @return magicValue A value indicating that the transfers were successful. */ function bulkTransfer( TransferHelperItemsWithRecipient[] calldata items, bytes32 conduitKey ) external override returns (bytes4 magicValue) { // Ensure that a conduit key has been supplied. if (conduitKey == bytes32(0)) { revert InvalidConduit(conduitKey, address(0)); } // Use conduit derived from supplied conduit key to perform transfers. _performTransfersWithConduit(items, conduitKey); // Return a magic value indicating that the transfers were performed. magicValue = this.bulkTransfer.selector; } /** * @notice Perform multiple transfers to specified recipients via the * conduit derived from the provided conduit key. * * @param transfers The items to transfer. * @param conduitKey The conduit key referring to the conduit through * which the bulk transfer should occur. */ function _performTransfersWithConduit( TransferHelperItemsWithRecipient[] calldata transfers, bytes32 conduitKey ) internal { // Retrieve total number of transfers and place on stack. uint256 numTransfers = transfers.length; // Derive the conduit address from the deployer, conduit key // and creation code hash. address conduit = address( uint160( uint256( keccak256( abi.encodePacked( bytes1(0xff), address(_CONDUIT_CONTROLLER), conduitKey, _CONDUIT_CREATION_CODE_HASH ) ) ) ) ); // Declare a variable to store the sum of all items across transfers. uint256 sumOfItemsAcrossAllTransfers; // Skip overflow checks: all for loops are indexed starting at zero. unchecked { // Iterate over each transfer. for (uint256 i = 0; i < numTransfers; ++i) { // Retrieve the transfer in question. TransferHelperItemsWithRecipient calldata transfer = transfers[ i ]; // Increment totalItems by the number of items in the transfer. sumOfItemsAcrossAllTransfers += transfer.items.length; } } // Declare a new array in memory with length totalItems to populate with // each conduit transfer. ConduitTransfer[] memory conduitTransfers = new ConduitTransfer[]( sumOfItemsAcrossAllTransfers ); // Declare an index for storing ConduitTransfers in conduitTransfers. uint256 itemIndex; // Skip overflow checks: all for loops are indexed starting at zero. unchecked { // Iterate over each transfer. for (uint256 i = 0; i < numTransfers; ++i) { // Retrieve the transfer in question. TransferHelperItemsWithRecipient calldata transfer = transfers[ i ]; // Retrieve the items of the transfer in question. TransferHelperItem[] calldata transferItems = transfer.items; // Ensure recipient is not the zero address. _checkRecipientIsNotZeroAddress(transfer.recipient); // Create a boolean indicating whether validateERC721Receiver // is true and recipient is a contract. bool callERC721Receiver = transfer.validateERC721Receiver && transfer.recipient.code.length != 0; // Retrieve the total number of items in the transfer and // place on stack. uint256 numItemsInTransfer = transferItems.length; // Iterate over each item in the transfer to create a // corresponding ConduitTransfer. for (uint256 j = 0; j < numItemsInTransfer; ++j) { // Retrieve the item from the transfer. TransferHelperItem calldata item = transferItems[j]; if (item.itemType == ConduitItemType.ERC20) { // Ensure that the identifier of an ERC20 token is 0. if (item.identifier != 0) { revert InvalidERC20Identifier(); } } // If the item is an ERC721 token and // callERC721Receiver is true... if (item.itemType == ConduitItemType.ERC721) { if (callERC721Receiver) { // Check if the recipient implements // onERC721Received for the given tokenId. _checkERC721Receiver( conduit, transfer.recipient, item.identifier ); } } // Create a ConduitTransfer corresponding to each // TransferHelperItem. conduitTransfers[itemIndex] = ConduitTransfer( item.itemType, item.token, msg.sender, transfer.recipient, item.identifier, item.amount ); // Increment the index for storing ConduitTransfers. ++itemIndex; } } } // Attempt the external call to transfer tokens via the derived conduit. try ConduitInterface(conduit).execute(conduitTransfers) returns ( bytes4 conduitMagicValue ) { // Check if the value returned from the external call matches // the conduit `execute` selector. if (conduitMagicValue != ConduitInterface.execute.selector) { // If the external call fails, revert with the conduit key // and conduit address. revert InvalidConduit(conduitKey, conduit); } } catch Error(string memory reason) { // Catch reverts with a provided reason string and // revert with the reason, conduit key and conduit address. revert ConduitErrorRevertString(reason, conduitKey, conduit); } catch (bytes memory data) { // Conduits will throw a custom error when attempting to transfer // native token item types or an ERC721 item amount other than 1. // Bubble up these custom errors when encountered. Note that the // conduit itself will bubble up revert reasons from transfers as // well, meaning that these errors are not necessarily indicative of // an issue with the item type or amount in cases where the same // custom error signature is encountered during a conduit transfer. // Set initial value of first four bytes of revert data to the mask. bytes4 customErrorSelector = bytes4(0xffffffff); // Utilize assembly to read first four bytes (if present) directly. assembly { // Combine original mask with first four bytes of revert data. customErrorSelector := and( mload(add(data, 0x20)), // Data begins after length offset. customErrorSelector ) } // Pass through the custom error in question if the revert data is // the correct length and matches an expected custom error selector. if ( data.length == 4 && (customErrorSelector == InvalidItemType.selector || customErrorSelector == InvalidERC721TransferAmount.selector) ) { // "Bubble up" the revert reason. assembly { revert(add(data, 0x20), 0x04) } } // Catch all other reverts from the external call to the conduit and // include the conduit's raw revert reason as a data argument to a // new custom error. revert ConduitErrorRevertBytes(data, conduitKey, conduit); } } /** * @notice An internal function to check if a recipient address implements * onERC721Received for a given tokenId. Note that this check does * not adhere to the safe transfer specification and is only meant * to provide an additional layer of assurance that the recipient * can receive the tokens — any hooks or post-transfer checks will * fail and the caller will be the transfer helper rather than the * ERC721 contract. Note that the conduit is set as the operator, as * it will be the caller once the transfer is performed. * * @param conduit The conduit to provide as the operator when calling * onERC721Received. * @param recipient The ERC721 recipient on which to call onERC721Received. * @param tokenId The ERC721 tokenId of the token being transferred. */ function _checkERC721Receiver( address conduit, address recipient, uint256 tokenId ) internal { // Check if recipient can receive ERC721 tokens. try IERC721Receiver(recipient).onERC721Received( conduit, msg.sender, tokenId, "" ) returns (bytes4 selector) { // Check if onERC721Received selector is valid. if (selector != IERC721Receiver.onERC721Received.selector) { // Revert if recipient cannot accept // ERC721 tokens. revert InvalidERC721Recipient(recipient); } } catch (bytes memory data) { // "Bubble up" recipient's revert reason. revert ERC721ReceiverErrorRevertBytes( data, recipient, msg.sender, tokenId ); } catch Error(string memory reason) { // "Bubble up" recipient's revert reason. revert ERC721ReceiverErrorRevertString( reason, recipient, msg.sender, tokenId ); } } /** * @notice An internal function that reverts if the passed-in recipient * is the zero address. * * @param recipient The recipient on which to perform the check. */ function _checkRecipientIsNotZeroAddress(address recipient) internal pure { // Revert if the recipient is the zero address. if (recipient == address(0x0)) { revert RecipientCannotBeZeroAddress(); } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; interface IERC721Receiver { function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; import { ConduitItemType } from "../conduit/lib/ConduitEnums.sol"; /** * @dev A TransferHelperItem specifies the itemType (ERC20/ERC721/ERC1155), * token address, token identifier, and amount of the token to be * transferred via the TransferHelper. For ERC20 tokens, identifier * must be 0. For ERC721 tokens, amount must be 1. */ struct TransferHelperItem { ConduitItemType itemType; address token; uint256 identifier; uint256 amount; } /** * @dev A TransferHelperItemsWithRecipient specifies the tokens to transfer * via the TransferHelper, their intended recipient, and a boolean flag * indicating whether onERC721Received should be called on a recipient * contract. */ struct TransferHelperItemsWithRecipient { TransferHelperItem[] items; address recipient; bool validateERC721Receiver; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; import { ConduitTransfer, ConduitBatch1155Transfer } from "../conduit/lib/ConduitStructs.sol"; /** * @title ConduitInterface * @author 0age * @notice ConduitInterface contains all external function interfaces, events, * and errors for conduit contracts. */ interface ConduitInterface { /** * @dev Revert with an error when attempting to execute transfers using a * caller that does not have an open channel. */ error ChannelClosed(address channel); /** * @dev Revert with an error when attempting to update a channel to the * current status of that channel. */ error ChannelStatusAlreadySet(address channel, bool isOpen); /** * @dev Revert with an error when attempting to execute a transfer for an * item that does not have an ERC20/721/1155 item type. */ error InvalidItemType(); /** * @dev Revert with an error when attempting to update the status of a * channel from a caller that is not the conduit controller. */ error InvalidController(); /** * @dev Emit an event whenever a channel is opened or closed. * * @param channel The channel that has been updated. * @param open A boolean indicating whether the conduit is open or not. */ event ChannelUpdated(address indexed channel, bool open); /** * @notice Execute a sequence of ERC20/721/1155 transfers. Only a caller * with an open channel can call this function. * * @param transfers The ERC20/721/1155 transfers to perform. * * @return magicValue A magic value indicating that the transfers were * performed successfully. */ function execute(ConduitTransfer[] calldata transfers) external returns (bytes4 magicValue); /** * @notice Execute a sequence of batch 1155 transfers. Only a caller with an * open channel can call this function. * * @param batch1155Transfers The 1155 batch transfers to perform. * * @return magicValue A magic value indicating that the transfers were * performed successfully. */ function executeBatch1155( ConduitBatch1155Transfer[] calldata batch1155Transfers ) external returns (bytes4 magicValue); /** * @notice Execute a sequence of transfers, both single and batch 1155. Only * a caller with an open channel can call this function. * * @param standardTransfers The ERC20/721/1155 transfers to perform. * @param batch1155Transfers The 1155 batch transfers to perform. * * @return magicValue A magic value indicating that the transfers were * performed successfully. */ function executeWithBatch1155( ConduitTransfer[] calldata standardTransfers, ConduitBatch1155Transfer[] calldata batch1155Transfers ) external returns (bytes4 magicValue); /** * @notice Open or close a given channel. Only callable by the controller. * * @param channel The channel to open or close. * @param isOpen The status of the channel (either open or closed). */ function updateChannel(address channel, bool isOpen) external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; /** * @title ConduitControllerInterface * @author 0age * @notice ConduitControllerInterface contains all external function interfaces, * structs, events, and errors for the conduit controller. */ interface ConduitControllerInterface { /** * @dev Track the conduit key, current owner, new potential owner, and open * channels for each deployed conduit. */ struct ConduitProperties { bytes32 key; address owner; address potentialOwner; address[] channels; mapping(address => uint256) channelIndexesPlusOne; } /** * @dev Emit an event whenever a new conduit is created. * * @param conduit The newly created conduit. * @param conduitKey The conduit key used to create the new conduit. */ event NewConduit(address conduit, bytes32 conduitKey); /** * @dev Emit an event whenever conduit ownership is transferred. * * @param conduit The conduit for which ownership has been * transferred. * @param previousOwner The previous owner of the conduit. * @param newOwner The new owner of the conduit. */ event OwnershipTransferred( address indexed conduit, address indexed previousOwner, address indexed newOwner ); /** * @dev Emit an event whenever a conduit owner registers a new potential * owner for that conduit. * * @param newPotentialOwner The new potential owner of the conduit. */ event PotentialOwnerUpdated(address indexed newPotentialOwner); /** * @dev Revert with an error when attempting to create a new conduit using a * conduit key where the first twenty bytes of the key do not match the * address of the caller. */ error InvalidCreator(); /** * @dev Revert with an error when attempting to create a new conduit when no * initial owner address is supplied. */ error InvalidInitialOwner(); /** * @dev Revert with an error when attempting to set a new potential owner * that is already set. */ error NewPotentialOwnerAlreadySet( address conduit, address newPotentialOwner ); /** * @dev Revert with an error when attempting to cancel ownership transfer * when no new potential owner is currently set. */ error NoPotentialOwnerCurrentlySet(address conduit); /** * @dev Revert with an error when attempting to interact with a conduit that * does not yet exist. */ error NoConduit(); /** * @dev Revert with an error when attempting to create a conduit that * already exists. */ error ConduitAlreadyExists(address conduit); /** * @dev Revert with an error when attempting to update channels or transfer * ownership of a conduit when the caller is not the owner of the * conduit in question. */ error CallerIsNotOwner(address conduit); /** * @dev Revert with an error when attempting to register a new potential * owner and supplying the null address. */ error NewPotentialOwnerIsZeroAddress(address conduit); /** * @dev Revert with an error when attempting to claim ownership of a conduit * with a caller that is not the current potential owner for the * conduit in question. */ error CallerIsNotNewPotentialOwner(address conduit); /** * @dev Revert with an error when attempting to retrieve a channel using an * index that is out of range. */ error ChannelOutOfRange(address conduit); /** * @notice Deploy a new conduit using a supplied conduit key and assigning * an initial owner for the deployed conduit. Note that the first * twenty bytes of the supplied conduit key must match the caller * and that a new conduit cannot be created if one has already been * deployed using the same conduit key. * * @param conduitKey The conduit key used to deploy the conduit. Note that * the first twenty bytes of the conduit key must match * the caller of this contract. * @param initialOwner The initial owner to set for the new conduit. * * @return conduit The address of the newly deployed conduit. */ function createConduit(bytes32 conduitKey, address initialOwner) external returns (address conduit); /** * @notice Open or close a channel on a given conduit, thereby allowing the * specified account to execute transfers against that conduit. * Extreme care must be taken when updating channels, as malicious * or vulnerable channels can transfer any ERC20, ERC721 and ERC1155 * tokens where the token holder has granted the conduit approval. * Only the owner of the conduit in question may call this function. * * @param conduit The conduit for which to open or close the channel. * @param channel The channel to open or close on the conduit. * @param isOpen A boolean indicating whether to open or close the channel. */ function updateChannel( address conduit, address channel, bool isOpen ) external; /** * @notice Initiate conduit ownership transfer by assigning a new potential * owner for the given conduit. Once set, the new potential owner * may call `acceptOwnership` to claim ownership of the conduit. * Only the owner of the conduit in question may call this function. * * @param conduit The conduit for which to initiate ownership transfer. * @param newPotentialOwner The new potential owner of the conduit. */ function transferOwnership(address conduit, address newPotentialOwner) external; /** * @notice Clear the currently set potential owner, if any, from a conduit. * Only the owner of the conduit in question may call this function. * * @param conduit The conduit for which to cancel ownership transfer. */ function cancelOwnershipTransfer(address conduit) external; /** * @notice Accept ownership of a supplied conduit. Only accounts that the * current owner has set as the new potential owner may call this * function. * * @param conduit The conduit for which to accept ownership. */ function acceptOwnership(address conduit) external; /** * @notice Retrieve the current owner of a deployed conduit. * * @param conduit The conduit for which to retrieve the associated owner. * * @return owner The owner of the supplied conduit. */ function ownerOf(address conduit) external view returns (address owner); /** * @notice Retrieve the conduit key for a deployed conduit via reverse * lookup. * * @param conduit The conduit for which to retrieve the associated conduit * key. * * @return conduitKey The conduit key used to deploy the supplied conduit. */ function getKey(address conduit) external view returns (bytes32 conduitKey); /** * @notice Derive the conduit associated with a given conduit key and * determine whether that conduit exists (i.e. whether it has been * deployed). * * @param conduitKey The conduit key used to derive the conduit. * * @return conduit The derived address of the conduit. * @return exists A boolean indicating whether the derived conduit has been * deployed or not. */ function getConduit(bytes32 conduitKey) external view returns (address conduit, bool exists); /** * @notice Retrieve the potential owner, if any, for a given conduit. The * current owner may set a new potential owner via * `transferOwnership` and that owner may then accept ownership of * the conduit in question via `acceptOwnership`. * * @param conduit The conduit for which to retrieve the potential owner. * * @return potentialOwner The potential owner, if any, for the conduit. */ function getPotentialOwner(address conduit) external view returns (address potentialOwner); /** * @notice Retrieve the status (either open or closed) of a given channel on * a conduit. * * @param conduit The conduit for which to retrieve the channel status. * @param channel The channel for which to retrieve the status. * * @return isOpen The status of the channel on the given conduit. */ function getChannelStatus(address conduit, address channel) external view returns (bool isOpen); /** * @notice Retrieve the total number of open channels for a given conduit. * * @param conduit The conduit for which to retrieve the total channel count. * * @return totalChannels The total number of open channels for the conduit. */ function getTotalChannels(address conduit) external view returns (uint256 totalChannels); /** * @notice Retrieve an open channel at a specific index for a given conduit. * Note that the index of a channel can change as a result of other * channels being closed on the conduit. * * @param conduit The conduit for which to retrieve the open channel. * @param channelIndex The index of the channel in question. * * @return channel The open channel, if any, at the specified channel index. */ function getChannel(address conduit, uint256 channelIndex) external view returns (address channel); /** * @notice Retrieve all open channels for a given conduit. Note that calling * this function for a conduit with many channels will revert with * an out-of-gas error. * * @param conduit The conduit for which to retrieve open channels. * * @return channels An array of open channels on the given conduit. */ function getChannels(address conduit) external view returns (address[] memory channels); /** * @dev Retrieve the conduit creation code and runtime code hashes. */ function getConduitCodeHashes() external view returns (bytes32 creationCodeHash, bytes32 runtimeCodeHash); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; import { ConduitInterface } from "../interfaces/ConduitInterface.sol"; import { ConduitItemType } from "./lib/ConduitEnums.sol"; import { TokenTransferrer } from "../lib/TokenTransferrer.sol"; import { ConduitTransfer, ConduitBatch1155Transfer } from "./lib/ConduitStructs.sol"; import "./lib/ConduitConstants.sol"; /** * @title Conduit * @author 0age * @notice This contract serves as an originator for "proxied" transfers. Each * conduit is deployed and controlled by a "conduit controller" that can * add and remove "channels" or contracts that can instruct the conduit * to transfer approved ERC20/721/1155 tokens. *IMPORTANT NOTE: each * conduit has an owner that can arbitrarily add or remove channels, and * a malicious or negligent owner can add a channel that allows for any * approved ERC20/721/1155 tokens to be taken immediately — be extremely * cautious with what conduits you give token approvals to!* */ contract Conduit is ConduitInterface, TokenTransferrer { // Set deployer as an immutable controller that can update channel statuses. address private immutable _controller; // Track the status of each channel. mapping(address => bool) private _channels; /** * @notice Ensure that the caller is currently registered as an open channel * on the conduit. */ modifier onlyOpenChannel() { // Utilize assembly to access channel storage mapping directly. assembly { // Write the caller to scratch space. mstore(ChannelKey_channel_ptr, caller()) // Write the storage slot for _channels to scratch space. mstore(ChannelKey_slot_ptr, _channels.slot) // Derive the position in storage of _channels[msg.sender] // and check if the stored value is zero. if iszero( sload(keccak256(ChannelKey_channel_ptr, ChannelKey_length)) ) { // The caller is not an open channel; revert with // ChannelClosed(caller). First, set error signature in memory. mstore(ChannelClosed_error_ptr, ChannelClosed_error_signature) // Next, set the caller as the argument. mstore(ChannelClosed_channel_ptr, caller()) // Finally, revert, returning full custom error with argument. revert(ChannelClosed_error_ptr, ChannelClosed_error_length) } } // Continue with function execution. _; } /** * @notice In the constructor, set the deployer as the controller. */ constructor() { // Set the deployer as the controller. _controller = msg.sender; } /** * @notice Execute a sequence of ERC20/721/1155 transfers. Only a caller * with an open channel can call this function. Note that channels * are expected to implement reentrancy protection if desired, and * that cross-channel reentrancy may be possible if the conduit has * multiple open channels at once. Also note that channels are * expected to implement checks against transferring any zero-amount * items if that constraint is desired. * * @param transfers The ERC20/721/1155 transfers to perform. * * @return magicValue A magic value indicating that the transfers were * performed successfully. */ function execute(ConduitTransfer[] calldata transfers) external override onlyOpenChannel returns (bytes4 magicValue) { // Retrieve the total number of transfers and place on the stack. uint256 totalStandardTransfers = transfers.length; // Iterate over each transfer. for (uint256 i = 0; i < totalStandardTransfers; ) { // Retrieve the transfer in question and perform the transfer. _transfer(transfers[i]); // Skip overflow check as for loop is indexed starting at zero. unchecked { ++i; } } // Return a magic value indicating that the transfers were performed. magicValue = this.execute.selector; } /** * @notice Execute a sequence of batch 1155 item transfers. Only a caller * with an open channel can call this function. Note that channels * are expected to implement reentrancy protection if desired, and * that cross-channel reentrancy may be possible if the conduit has * multiple open channels at once. Also note that channels are * expected to implement checks against transferring any zero-amount * items if that constraint is desired. * * @param batchTransfers The 1155 batch item transfers to perform. * * @return magicValue A magic value indicating that the item transfers were * performed successfully. */ function executeBatch1155( ConduitBatch1155Transfer[] calldata batchTransfers ) external override onlyOpenChannel returns (bytes4 magicValue) { // Perform 1155 batch transfers. Note that memory should be considered // entirely corrupted from this point forward. _performERC1155BatchTransfers(batchTransfers); // Return a magic value indicating that the transfers were performed. magicValue = this.executeBatch1155.selector; } /** * @notice Execute a sequence of transfers, both single ERC20/721/1155 item * transfers as well as batch 1155 item transfers. Only a caller * with an open channel can call this function. Note that channels * are expected to implement reentrancy protection if desired, and * that cross-channel reentrancy may be possible if the conduit has * multiple open channels at once. Also note that channels are * expected to implement checks against transferring any zero-amount * items if that constraint is desired. * * @param standardTransfers The ERC20/721/1155 item transfers to perform. * @param batchTransfers The 1155 batch item transfers to perform. * * @return magicValue A magic value indicating that the item transfers were * performed successfully. */ function executeWithBatch1155( ConduitTransfer[] calldata standardTransfers, ConduitBatch1155Transfer[] calldata batchTransfers ) external override onlyOpenChannel returns (bytes4 magicValue) { // Retrieve the total number of transfers and place on the stack. uint256 totalStandardTransfers = standardTransfers.length; // Iterate over each standard transfer. for (uint256 i = 0; i < totalStandardTransfers; ) { // Retrieve the transfer in question and perform the transfer. _transfer(standardTransfers[i]); // Skip overflow check as for loop is indexed starting at zero. unchecked { ++i; } } // Perform 1155 batch transfers. Note that memory should be considered // entirely corrupted from this point forward aside from the free memory // pointer having the default value. _performERC1155BatchTransfers(batchTransfers); // Return a magic value indicating that the transfers were performed. magicValue = this.executeWithBatch1155.selector; } /** * @notice Open or close a given channel. Only callable by the controller. * * @param channel The channel to open or close. * @param isOpen The status of the channel (either open or closed). */ function updateChannel(address channel, bool isOpen) external override { // Ensure that the caller is the controller of this contract. if (msg.sender != _controller) { revert InvalidController(); } // Ensure that the channel does not already have the indicated status. if (_channels[channel] == isOpen) { revert ChannelStatusAlreadySet(channel, isOpen); } // Update the status of the channel. _channels[channel] = isOpen; // Emit a corresponding event. emit ChannelUpdated(channel, isOpen); } /** * @dev Internal function to transfer a given ERC20/721/1155 item. Note that * channels are expected to implement checks against transferring any * zero-amount items if that constraint is desired. * * @param item The ERC20/721/1155 item to transfer. */ function _transfer(ConduitTransfer calldata item) internal { // Determine the transfer method based on the respective item type. if (item.itemType == ConduitItemType.ERC20) { // Transfer ERC20 token. Note that item.identifier is ignored and // therefore ERC20 transfer items are potentially malleable — this // check should be performed by the calling channel if a constraint // on item malleability is desired. _performERC20Transfer(item.token, item.from, item.to, item.amount); } else if (item.itemType == ConduitItemType.ERC721) { // Ensure that exactly one 721 item is being transferred. if (item.amount != 1) { revert InvalidERC721TransferAmount(); } // Transfer ERC721 token. _performERC721Transfer( item.token, item.from, item.to, item.identifier ); } else if (item.itemType == ConduitItemType.ERC1155) { // Transfer ERC1155 token. _performERC1155Transfer( item.token, item.from, item.to, item.identifier, item.amount ); } else { // Throw with an error. revert InvalidItemType(); } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; import { ConduitItemType } from "./ConduitEnums.sol"; struct ConduitTransfer { ConduitItemType itemType; address token; address from; address to; uint256 identifier; uint256 amount; } struct ConduitBatch1155Transfer { address token; address from; address to; uint256[] ids; uint256[] amounts; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; import { TransferHelperItem, TransferHelperItemsWithRecipient } from "../helpers/TransferHelperStructs.sol"; interface TransferHelperInterface { /** * @notice Transfer multiple items to a single recipient. * * @param items The items to transfer. * @param conduitKey The key of the conduit performing the bulk transfer. */ function bulkTransfer( TransferHelperItemsWithRecipient[] calldata items, bytes32 conduitKey ) external returns (bytes4); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; /** * @title TransferHelperErrors */ interface TransferHelperErrors { /** * @dev Revert with an error when attempting to execute transfers with a * NATIVE itemType. */ error InvalidItemType(); /** * @dev Revert with an error when an ERC721 transfer with amount other than * one is attempted. */ error InvalidERC721TransferAmount(); /** * @dev Revert with an error when attempting to execute an ERC721 transfer * to an invalid recipient. */ error InvalidERC721Recipient(address recipient); /** * @dev Revert with an error when a call to a ERC721 receiver reverts with * bytes data. */ error ERC721ReceiverErrorRevertBytes( bytes reason, address receiver, address sender, uint256 identifier ); /** * @dev Revert with an error when a call to a ERC721 receiver reverts with * string reason. */ error ERC721ReceiverErrorRevertString( string reason, address receiver, address sender, uint256 identifier ); /** * @dev Revert with an error when an ERC20 token has an invalid identifier. */ error InvalidERC20Identifier(); /** * @dev Revert with an error if the recipient is the zero address. */ error RecipientCannotBeZeroAddress(); /** * @dev Revert with an error when attempting to fill an order referencing an * invalid conduit (i.e. one that has not been deployed). */ error InvalidConduit(bytes32 conduitKey, address conduit); /** * @dev Revert with an error when a call to a conduit reverts with a * reason string. */ error ConduitErrorRevertString( string reason, bytes32 conduitKey, address conduit ); /** * @dev Revert with an error when a call to a conduit reverts with bytes * data. */ error ConduitErrorRevertBytes( bytes reason, bytes32 conduitKey, address conduit ); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; enum ConduitItemType { NATIVE, // unused ERC20, ERC721, ERC1155 }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; import "./TokenTransferrerConstants.sol"; import { TokenTransferrerErrors } from "../interfaces/TokenTransferrerErrors.sol"; import { ConduitBatch1155Transfer } from "../conduit/lib/ConduitStructs.sol"; /** * @title TokenTransferrer * @author 0age * @custom:coauthor d1ll0n * @custom:coauthor transmissions11 * @notice TokenTransferrer is a library for performing optimized ERC20, ERC721, * ERC1155, and batch ERC1155 transfers, used by both Seaport as well as * by conduits deployed by the ConduitController. Use great caution when * considering these functions for use in other codebases, as there are * significant side effects and edge cases that need to be thoroughly * understood and carefully addressed. */ contract TokenTransferrer is TokenTransferrerErrors { /** * @dev Internal function to transfer ERC20 tokens from a given originator * to a given recipient. Sufficient approvals must be set on the * contract performing the transfer. * * @param token The ERC20 token to transfer. * @param from The originator of the transfer. * @param to The recipient of the transfer. * @param amount The amount to transfer. */ function _performERC20Transfer( address token, address from, address to, uint256 amount ) internal { // Utilize assembly to perform an optimized ERC20 token transfer. assembly { // The free memory pointer memory slot will be used when populating // call data for the transfer; read the value and restore it later. let memPointer := mload(FreeMemoryPointerSlot) // Write call data into memory, starting with function selector. mstore(ERC20_transferFrom_sig_ptr, ERC20_transferFrom_signature) mstore(ERC20_transferFrom_from_ptr, from) mstore(ERC20_transferFrom_to_ptr, to) mstore(ERC20_transferFrom_amount_ptr, amount) // Make call & copy up to 32 bytes of return data to scratch space. // Scratch space does not need to be cleared ahead of time, as the // subsequent check will ensure that either at least a full word of // return data is received (in which case it will be overwritten) or // that no data is received (in which case scratch space will be // ignored) on a successful call to the given token. let callStatus := call( gas(), token, 0, ERC20_transferFrom_sig_ptr, ERC20_transferFrom_length, 0, OneWord ) // Determine whether transfer was successful using status & result. let success := and( // Set success to whether the call reverted, if not check it // either returned exactly 1 (can't just be non-zero data), or // had no return data. or( and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize()) ), callStatus ) // Handle cases where either the transfer failed or no data was // returned. Group these, as most transfers will succeed with data. // Equivalent to `or(iszero(success), iszero(returndatasize()))` // but after it's inverted for JUMPI this expression is cheaper. if iszero(and(success, iszero(iszero(returndatasize())))) { // If the token has no code or the transfer failed: Equivalent // to `or(iszero(success), iszero(extcodesize(token)))` but // after it's inverted for JUMPI this expression is cheaper. if iszero(and(iszero(iszero(extcodesize(token))), success)) { // If the transfer failed: if iszero(success) { // If it was due to a revert: if iszero(callStatus) { // If it returned a message, bubble it up as long as // sufficient gas remains to do so: if returndatasize() { // Ensure that sufficient gas is available to // copy returndata while expanding memory where // necessary. Start by computing the word size // of returndata and allocated memory. Round up // to the nearest full word. let returnDataWords := div( add(returndatasize(), AlmostOneWord), OneWord ) // Note: use the free memory pointer in place of // msize() to work around a Yul warning that // prevents accessing msize directly when the IR // pipeline is activated. let msizeWords := div(memPointer, OneWord) // Next, compute the cost of the returndatacopy. let cost := mul(CostPerWord, returnDataWords) // Then, compute cost of new memory allocation. if gt(returnDataWords, msizeWords) { cost := add( cost, add( mul( sub( returnDataWords, msizeWords ), CostPerWord ), div( sub( mul( returnDataWords, returnDataWords ), mul(msizeWords, msizeWords) ), MemoryExpansionCoefficient ) ) ) } // Finally, add a small constant and compare to // gas remaining; bubble up the revert data if // enough gas is still available. if lt(add(cost, ExtraGasBuffer), gas()) { // Copy returndata to memory; overwrite // existing memory. returndatacopy(0, 0, returndatasize()) // Revert, specifying memory region with // copied returndata. revert(0, returndatasize()) } } // Otherwise revert with a generic error message. mstore( TokenTransferGenericFailure_error_sig_ptr, TokenTransferGenericFailure_error_signature ) mstore( TokenTransferGenericFailure_error_token_ptr, token ) mstore( TokenTransferGenericFailure_error_from_ptr, from ) mstore(TokenTransferGenericFailure_error_to_ptr, to) mstore(TokenTransferGenericFailure_error_id_ptr, 0) mstore( TokenTransferGenericFailure_error_amount_ptr, amount ) revert( TokenTransferGenericFailure_error_sig_ptr, TokenTransferGenericFailure_error_length ) } // Otherwise revert with a message about the token // returning false or non-compliant return values. mstore( BadReturnValueFromERC20OnTransfer_error_sig_ptr, BadReturnValueFromERC20OnTransfer_error_signature ) mstore( BadReturnValueFromERC20OnTransfer_error_token_ptr, token ) mstore( BadReturnValueFromERC20OnTransfer_error_from_ptr, from ) mstore( BadReturnValueFromERC20OnTransfer_error_to_ptr, to ) mstore( BadReturnValueFromERC20OnTransfer_error_amount_ptr, amount ) revert( BadReturnValueFromERC20OnTransfer_error_sig_ptr, BadReturnValueFromERC20OnTransfer_error_length ) } // Otherwise, revert with error about token not having code: mstore(NoContract_error_sig_ptr, NoContract_error_signature) mstore(NoContract_error_token_ptr, token) revert(NoContract_error_sig_ptr, NoContract_error_length) } // Otherwise, the token just returned no data despite the call // having succeeded; no need to optimize for this as it's not // technically ERC20 compliant. } // Restore the original free memory pointer. mstore(FreeMemoryPointerSlot, memPointer) // Restore the zero slot to zero. mstore(ZeroSlot, 0) } } /** * @dev Internal function to transfer an ERC721 token from a given * originator to a given recipient. Sufficient approvals must be set on * the contract performing the transfer. Note that this function does * not check whether the receiver can accept the ERC721 token (i.e. it * does not use `safeTransferFrom`). * * @param token The ERC721 token to transfer. * @param from The originator of the transfer. * @param to The recipient of the transfer. * @param identifier The tokenId to transfer. */ function _performERC721Transfer( address token, address from, address to, uint256 identifier ) internal { // Utilize assembly to perform an optimized ERC721 token transfer. assembly { // If the token has no code, revert. if iszero(extcodesize(token)) { mstore(NoContract_error_sig_ptr, NoContract_error_signature) mstore(NoContract_error_token_ptr, token) revert(NoContract_error_sig_ptr, NoContract_error_length) } // The free memory pointer memory slot will be used when populating // call data for the transfer; read the value and restore it later. let memPointer := mload(FreeMemoryPointerSlot) // Write call data to memory starting with function selector. mstore(ERC721_transferFrom_sig_ptr, ERC721_transferFrom_signature) mstore(ERC721_transferFrom_from_ptr, from) mstore(ERC721_transferFrom_to_ptr, to) mstore(ERC721_transferFrom_id_ptr, identifier) // Perform the call, ignoring return data. let success := call( gas(), token, 0, ERC721_transferFrom_sig_ptr, ERC721_transferFrom_length, 0, 0 ) // If the transfer reverted: if iszero(success) { // If it returned a message, bubble it up as long as sufficient // gas remains to do so: if returndatasize() { // Ensure that sufficient gas is available to copy // returndata while expanding memory where necessary. Start // by computing word size of returndata & allocated memory. // Round up to the nearest full word. let returnDataWords := div( add(returndatasize(), AlmostOneWord), OneWord ) // Note: use the free memory pointer in place of msize() to // work around a Yul warning that prevents accessing msize // directly when the IR pipeline is activated. let msizeWords := div(memPointer, OneWord) // Next, compute the cost of the returndatacopy. let cost := mul(CostPerWord, returnDataWords) // Then, compute cost of new memory allocation. if gt(returnDataWords, msizeWords) { cost := add( cost, add( mul( sub(returnDataWords, msizeWords), CostPerWord ), div( sub( mul(returnDataWords, returnDataWords), mul(msizeWords, msizeWords) ), MemoryExpansionCoefficient ) ) ) } // Finally, add a small constant and compare to gas // remaining; bubble up the revert data if enough gas is // still available. if lt(add(cost, ExtraGasBuffer), gas()) { // Copy returndata to memory; overwrite existing memory. returndatacopy(0, 0, returndatasize()) // Revert, giving memory region with copied returndata. revert(0, returndatasize()) } } // Otherwise revert with a generic error message. mstore( TokenTransferGenericFailure_error_sig_ptr, TokenTransferGenericFailure_error_signature ) mstore(TokenTransferGenericFailure_error_token_ptr, token) mstore(TokenTransferGenericFailure_error_from_ptr, from) mstore(TokenTransferGenericFailure_error_to_ptr, to) mstore(TokenTransferGenericFailure_error_id_ptr, identifier) mstore(TokenTransferGenericFailure_error_amount_ptr, 1) revert( TokenTransferGenericFailure_error_sig_ptr, TokenTransferGenericFailure_error_length ) } // Restore the original free memory pointer. mstore(FreeMemoryPointerSlot, memPointer) // Restore the zero slot to zero. mstore(ZeroSlot, 0) } } /** * @dev Internal function to transfer ERC1155 tokens from a given * originator to a given recipient. Sufficient approvals must be set on * the contract performing the transfer and contract recipients must * implement the ERC1155TokenReceiver interface to indicate that they * are willing to accept the transfer. * * @param token The ERC1155 token to transfer. * @param from The originator of the transfer. * @param to The recipient of the transfer. * @param identifier The id to transfer. * @param amount The amount to transfer. */ function _performERC1155Transfer( address token, address from, address to, uint256 identifier, uint256 amount ) internal { // Utilize assembly to perform an optimized ERC1155 token transfer. assembly { // If the token has no code, revert. if iszero(extcodesize(token)) { mstore(NoContract_error_sig_ptr, NoContract_error_signature) mstore(NoContract_error_token_ptr, token) revert(NoContract_error_sig_ptr, NoContract_error_length) } // The following memory slots will be used when populating call data // for the transfer; read the values and restore them later. let memPointer := mload(FreeMemoryPointerSlot) let slot0x80 := mload(Slot0x80) let slot0xA0 := mload(Slot0xA0) let slot0xC0 := mload(Slot0xC0) // Write call data into memory, beginning with function selector. mstore( ERC1155_safeTransferFrom_sig_ptr, ERC1155_safeTransferFrom_signature ) mstore(ERC1155_safeTransferFrom_from_ptr, from) mstore(ERC1155_safeTransferFrom_to_ptr, to) mstore(ERC1155_safeTransferFrom_id_ptr, identifier) mstore(ERC1155_safeTransferFrom_amount_ptr, amount) mstore( ERC1155_safeTransferFrom_data_offset_ptr, ERC1155_safeTransferFrom_data_length_offset ) mstore(ERC1155_safeTransferFrom_data_length_ptr, 0) // Perform the call, ignoring return data. let success := call( gas(), token, 0, ERC1155_safeTransferFrom_sig_ptr, ERC1155_safeTransferFrom_length, 0, 0 ) // If the transfer reverted: if iszero(success) { // If it returned a message, bubble it up as long as sufficient // gas remains to do so: if returndatasize() { // Ensure that sufficient gas is available to copy // returndata while expanding memory where necessary. Start // by computing word size of returndata & allocated memory. // Round up to the nearest full word. let returnDataWords := div( add(returndatasize(), AlmostOneWord), OneWord ) // Note: use the free memory pointer in place of msize() to // work around a Yul warning that prevents accessing msize // directly when the IR pipeline is activated. let msizeWords := div(memPointer, OneWord) // Next, compute the cost of the returndatacopy. let cost := mul(CostPerWord, returnDataWords) // Then, compute cost of new memory allocation. if gt(returnDataWords, msizeWords) { cost := add( cost, add( mul( sub(returnDataWords, msizeWords), CostPerWord ), div( sub( mul(returnDataWords, returnDataWords), mul(msizeWords, msizeWords) ), MemoryExpansionCoefficient ) ) ) } // Finally, add a small constant and compare to gas // remaining; bubble up the revert data if enough gas is // still available. if lt(add(cost, ExtraGasBuffer), gas()) { // Copy returndata to memory; overwrite existing memory. returndatacopy(0, 0, returndatasize()) // Revert, giving memory region with copied returndata. revert(0, returndatasize()) } } // Otherwise revert with a generic error message. mstore( TokenTransferGenericFailure_error_sig_ptr, TokenTransferGenericFailure_error_signature ) mstore(TokenTransferGenericFailure_error_token_ptr, token) mstore(TokenTransferGenericFailure_error_from_ptr, from) mstore(TokenTransferGenericFailure_error_to_ptr, to) mstore(TokenTransferGenericFailure_error_id_ptr, identifier) mstore(TokenTransferGenericFailure_error_amount_ptr, amount) revert( TokenTransferGenericFailure_error_sig_ptr, TokenTransferGenericFailure_error_length ) } mstore(Slot0x80, slot0x80) // Restore slot 0x80. mstore(Slot0xA0, slot0xA0) // Restore slot 0xA0. mstore(Slot0xC0, slot0xC0) // Restore slot 0xC0. // Restore the original free memory pointer. mstore(FreeMemoryPointerSlot, memPointer) // Restore the zero slot to zero. mstore(ZeroSlot, 0) } } /** * @dev Internal function to transfer ERC1155 tokens from a given * originator to a given recipient. Sufficient approvals must be set on * the contract performing the transfer and contract recipients must * implement the ERC1155TokenReceiver interface to indicate that they * are willing to accept the transfer. NOTE: this function is not * memory-safe; it will overwrite existing memory, restore the free * memory pointer to the default value, and overwrite the zero slot. * This function should only be called once memory is no longer * required and when uninitialized arrays are not utilized, and memory * should be considered fully corrupted (aside from the existence of a * default-value free memory pointer) after calling this function. * * @param batchTransfers The group of 1155 batch transfers to perform. */ function _performERC1155BatchTransfers( ConduitBatch1155Transfer[] calldata batchTransfers ) internal { // Utilize assembly to perform optimized batch 1155 transfers. assembly { let len := batchTransfers.length // Pointer to first head in the array, which is offset to the struct // at each index. This gets incremented after each loop to avoid // multiplying by 32 to get the offset for each element. let nextElementHeadPtr := batchTransfers.offset // Pointer to beginning of the head of the array. This is the // reference position each offset references. It's held static to // let each loop calculate the data position for an element. let arrayHeadPtr := nextElementHeadPtr // Write the function selector, which will be reused for each call: // safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) mstore( ConduitBatch1155Transfer_from_offset, ERC1155_safeBatchTransferFrom_signature ) // Iterate over each batch transfer. for { let i := 0 } lt(i, len) { i := add(i, 1) } { // Read the offset to the beginning of the element and add // it to pointer to the beginning of the array head to get // the absolute position of the element in calldata. let elementPtr := add( arrayHeadPtr, calldataload(nextElementHeadPtr) ) // Retrieve the token from calldata. let token := calldataload(elementPtr) // If the token has no code, revert. if iszero(extcodesize(token)) { mstore(NoContract_error_sig_ptr, NoContract_error_signature) mstore(NoContract_error_token_ptr, token) revert(NoContract_error_sig_ptr, NoContract_error_length) } // Get the total number of supplied ids. let idsLength := calldataload( add(elementPtr, ConduitBatch1155Transfer_ids_length_offset) ) // Determine the expected offset for the amounts array. let expectedAmountsOffset := add( ConduitBatch1155Transfer_amounts_length_baseOffset, mul(idsLength, OneWord) ) // Validate struct encoding. let invalidEncoding := iszero( and( // ids.length == amounts.length eq( idsLength, calldataload(add(elementPtr, expectedAmountsOffset)) ), and( // ids_offset == 0xa0 eq( calldataload( add( elementPtr, ConduitBatch1155Transfer_ids_head_offset ) ), ConduitBatch1155Transfer_ids_length_offset ), // amounts_offset == 0xc0 + ids.length*32 eq( calldataload( add( elementPtr, ConduitBatchTransfer_amounts_head_offset ) ), expectedAmountsOffset ) ) ) ) // Revert with an error if the encoding is not valid. if invalidEncoding { mstore( Invalid1155BatchTransferEncoding_ptr, Invalid1155BatchTransferEncoding_selector ) revert( Invalid1155BatchTransferEncoding_ptr, Invalid1155BatchTransferEncoding_length ) } // Update the offset position for the next loop nextElementHeadPtr := add(nextElementHeadPtr, OneWord) // Copy the first section of calldata (before dynamic values). calldatacopy( BatchTransfer1155Params_ptr, add(elementPtr, ConduitBatch1155Transfer_from_offset), ConduitBatch1155Transfer_usable_head_size ) // Determine size of calldata required for ids and amounts. Note // that the size includes both lengths as well as the data. let idsAndAmountsSize := add(TwoWords, mul(idsLength, TwoWords)) // Update the offset for the data array in memory. mstore( BatchTransfer1155Params_data_head_ptr, add( BatchTransfer1155Params_ids_length_offset, idsAndAmountsSize ) ) // Set the length of the data array in memory to zero. mstore( add( BatchTransfer1155Params_data_length_basePtr, idsAndAmountsSize ), 0 ) // Determine the total calldata size for the call to transfer. let transferDataSize := add( BatchTransfer1155Params_calldata_baseSize, idsAndAmountsSize ) // Copy second section of calldata (including dynamic values). calldatacopy( BatchTransfer1155Params_ids_length_ptr, add(elementPtr, ConduitBatch1155Transfer_ids_length_offset), idsAndAmountsSize ) // Perform the call to transfer 1155 tokens. let success := call( gas(), token, 0, ConduitBatch1155Transfer_from_offset, // Data portion start. transferDataSize, // Location of the length of callData. 0, 0 ) // If the transfer reverted: if iszero(success) { // If it returned a message, bubble it up as long as // sufficient gas remains to do so: if returndatasize() { // Ensure that sufficient gas is available to copy // returndata while expanding memory where necessary. // Start by computing word size of returndata and // allocated memory. Round up to the nearest full word. let returnDataWords := div( add(returndatasize(), AlmostOneWord), OneWord ) // Note: use transferDataSize in place of msize() to // work around a Yul warning that prevents accessing // msize directly when the IR pipeline is activated. // The free memory pointer is not used here because // this function does almost all memory management // manually and does not update it, and transferDataSize // should be the largest memory value used (unless a // previous batch was larger). let msizeWords := div(transferDataSize, OneWord) // Next, compute the cost of the returndatacopy. let cost := mul(CostPerWord, returnDataWords) // Then, compute cost of new memory allocation. if gt(returnDataWords, msizeWords) { cost := add( cost, add( mul( sub(returnDataWords, msizeWords), CostPerWord ), div( sub( mul( returnDataWords, returnDataWords ), mul(msizeWords, msizeWords) ), MemoryExpansionCoefficient ) ) ) } // Finally, add a small constant and compare to gas // remaining; bubble up the revert data if enough gas is // still available. if lt(add(cost, ExtraGasBuffer), gas()) { // Copy returndata to memory; overwrite existing. returndatacopy(0, 0, returndatasize()) // Revert with memory region containing returndata. revert(0, returndatasize()) } } // Set the error signature. mstore( 0, ERC1155BatchTransferGenericFailure_error_signature ) // Write the token. mstore(ERC1155BatchTransferGenericFailure_token_ptr, token) // Increase the offset to ids by 32. mstore( BatchTransfer1155Params_ids_head_ptr, ERC1155BatchTransferGenericFailure_ids_offset ) // Increase the offset to amounts by 32. mstore( BatchTransfer1155Params_amounts_head_ptr, add( OneWord, mload(BatchTransfer1155Params_amounts_head_ptr) ) ) // Return modified region. The total size stays the same as // `token` uses the same number of bytes as `data.length`. revert(0, transferDataSize) } } // Reset the free memory pointer to the default value; memory must // be assumed to be dirtied and not reused from this point forward. // Also note that the zero slot is not reset to zero, meaning empty // arrays cannot be safely created or utilized until it is restored. mstore(FreeMemoryPointerSlot, DefaultFreeMemoryPointer) } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; // error ChannelClosed(address channel) uint256 constant ChannelClosed_error_signature = ( 0x93daadf200000000000000000000000000000000000000000000000000000000 ); uint256 constant ChannelClosed_error_ptr = 0x00; uint256 constant ChannelClosed_channel_ptr = 0x4; uint256 constant ChannelClosed_error_length = 0x24; // For the mapping: // mapping(address => bool) channels // The position in storage for a particular account is: // keccak256(abi.encode(account, channels.slot)) uint256 constant ChannelKey_channel_ptr = 0x00; uint256 constant ChannelKey_slot_ptr = 0x20; uint256 constant ChannelKey_length = 0x40;
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; /* * -------------------------- Disambiguation & Other Notes --------------------- * - The term "head" is used as it is in the documentation for ABI encoding, * but only in reference to dynamic types, i.e. it always refers to the * offset or pointer to the body of a dynamic type. In calldata, the head * is always an offset (relative to the parent object), while in memory, * the head is always the pointer to the body. More information found here: * https://docs.soliditylang.org/en/v0.8.14/abi-spec.html#argument-encoding * - Note that the length of an array is separate from and precedes the * head of the array. * * - The term "body" is used in place of the term "head" used in the ABI * documentation. It refers to the start of the data for a dynamic type, * e.g. the first word of a struct or the first word of the first element * in an array. * * - The term "pointer" is used to describe the absolute position of a value * and never an offset relative to another value. * - The suffix "_ptr" refers to a memory pointer. * - The suffix "_cdPtr" refers to a calldata pointer. * * - The term "offset" is used to describe the position of a value relative * to some parent value. For example, OrderParameters_conduit_offset is the * offset to the "conduit" value in the OrderParameters struct relative to * the start of the body. * - Note: Offsets are used to derive pointers. * * - Some structs have pointers defined for all of their fields in this file. * Lines which are commented out are fields that are not used in the * codebase but have been left in for readability. */ uint256 constant AlmostOneWord = 0x1f; uint256 constant OneWord = 0x20; uint256 constant TwoWords = 0x40; uint256 constant ThreeWords = 0x60; uint256 constant FreeMemoryPointerSlot = 0x40; uint256 constant ZeroSlot = 0x60; uint256 constant DefaultFreeMemoryPointer = 0x80; uint256 constant Slot0x80 = 0x80; uint256 constant Slot0xA0 = 0xa0; uint256 constant Slot0xC0 = 0xc0; // abi.encodeWithSignature("transferFrom(address,address,uint256)") uint256 constant ERC20_transferFrom_signature = ( 0x23b872dd00000000000000000000000000000000000000000000000000000000 ); uint256 constant ERC20_transferFrom_sig_ptr = 0x0; uint256 constant ERC20_transferFrom_from_ptr = 0x04; uint256 constant ERC20_transferFrom_to_ptr = 0x24; uint256 constant ERC20_transferFrom_amount_ptr = 0x44; uint256 constant ERC20_transferFrom_length = 0x64; // 4 + 32 * 3 == 100 // abi.encodeWithSignature( // "safeTransferFrom(address,address,uint256,uint256,bytes)" // ) uint256 constant ERC1155_safeTransferFrom_signature = ( 0xf242432a00000000000000000000000000000000000000000000000000000000 ); uint256 constant ERC1155_safeTransferFrom_sig_ptr = 0x0; uint256 constant ERC1155_safeTransferFrom_from_ptr = 0x04; uint256 constant ERC1155_safeTransferFrom_to_ptr = 0x24; uint256 constant ERC1155_safeTransferFrom_id_ptr = 0x44; uint256 constant ERC1155_safeTransferFrom_amount_ptr = 0x64; uint256 constant ERC1155_safeTransferFrom_data_offset_ptr = 0x84; uint256 constant ERC1155_safeTransferFrom_data_length_ptr = 0xa4; uint256 constant ERC1155_safeTransferFrom_length = 0xc4; // 4 + 32 * 6 == 196 uint256 constant ERC1155_safeTransferFrom_data_length_offset = 0xa0; // abi.encodeWithSignature( // "safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)" // ) uint256 constant ERC1155_safeBatchTransferFrom_signature = ( 0x2eb2c2d600000000000000000000000000000000000000000000000000000000 ); bytes4 constant ERC1155_safeBatchTransferFrom_selector = bytes4( bytes32(ERC1155_safeBatchTransferFrom_signature) ); uint256 constant ERC721_transferFrom_signature = ERC20_transferFrom_signature; uint256 constant ERC721_transferFrom_sig_ptr = 0x0; uint256 constant ERC721_transferFrom_from_ptr = 0x04; uint256 constant ERC721_transferFrom_to_ptr = 0x24; uint256 constant ERC721_transferFrom_id_ptr = 0x44; uint256 constant ERC721_transferFrom_length = 0x64; // 4 + 32 * 3 == 100 // abi.encodeWithSignature("NoContract(address)") uint256 constant NoContract_error_signature = ( 0x5f15d67200000000000000000000000000000000000000000000000000000000 ); uint256 constant NoContract_error_sig_ptr = 0x0; uint256 constant NoContract_error_token_ptr = 0x4; uint256 constant NoContract_error_length = 0x24; // 4 + 32 == 36 // abi.encodeWithSignature( // "TokenTransferGenericFailure(address,address,address,uint256,uint256)" // ) uint256 constant TokenTransferGenericFailure_error_signature = ( 0xf486bc8700000000000000000000000000000000000000000000000000000000 ); uint256 constant TokenTransferGenericFailure_error_sig_ptr = 0x0; uint256 constant TokenTransferGenericFailure_error_token_ptr = 0x4; uint256 constant TokenTransferGenericFailure_error_from_ptr = 0x24; uint256 constant TokenTransferGenericFailure_error_to_ptr = 0x44; uint256 constant TokenTransferGenericFailure_error_id_ptr = 0x64; uint256 constant TokenTransferGenericFailure_error_amount_ptr = 0x84; // 4 + 32 * 5 == 164 uint256 constant TokenTransferGenericFailure_error_length = 0xa4; // abi.encodeWithSignature( // "BadReturnValueFromERC20OnTransfer(address,address,address,uint256)" // ) uint256 constant BadReturnValueFromERC20OnTransfer_error_signature = ( 0x9889192300000000000000000000000000000000000000000000000000000000 ); uint256 constant BadReturnValueFromERC20OnTransfer_error_sig_ptr = 0x0; uint256 constant BadReturnValueFromERC20OnTransfer_error_token_ptr = 0x4; uint256 constant BadReturnValueFromERC20OnTransfer_error_from_ptr = 0x24; uint256 constant BadReturnValueFromERC20OnTransfer_error_to_ptr = 0x44; uint256 constant BadReturnValueFromERC20OnTransfer_error_amount_ptr = 0x64; // 4 + 32 * 4 == 132 uint256 constant BadReturnValueFromERC20OnTransfer_error_length = 0x84; uint256 constant ExtraGasBuffer = 0x20; uint256 constant CostPerWord = 3; uint256 constant MemoryExpansionCoefficient = 0x200; // Values are offset by 32 bytes in order to write the token to the beginning // in the event of a revert uint256 constant BatchTransfer1155Params_ptr = 0x24; uint256 constant BatchTransfer1155Params_ids_head_ptr = 0x64; uint256 constant BatchTransfer1155Params_amounts_head_ptr = 0x84; uint256 constant BatchTransfer1155Params_data_head_ptr = 0xa4; uint256 constant BatchTransfer1155Params_data_length_basePtr = 0xc4; uint256 constant BatchTransfer1155Params_calldata_baseSize = 0xc4; uint256 constant BatchTransfer1155Params_ids_length_ptr = 0xc4; uint256 constant BatchTransfer1155Params_ids_length_offset = 0xa0; uint256 constant BatchTransfer1155Params_amounts_length_baseOffset = 0xc0; uint256 constant BatchTransfer1155Params_data_length_baseOffset = 0xe0; uint256 constant ConduitBatch1155Transfer_usable_head_size = 0x80; uint256 constant ConduitBatch1155Transfer_from_offset = 0x20; uint256 constant ConduitBatch1155Transfer_ids_head_offset = 0x60; uint256 constant ConduitBatch1155Transfer_amounts_head_offset = 0x80; uint256 constant ConduitBatch1155Transfer_ids_length_offset = 0xa0; uint256 constant ConduitBatch1155Transfer_amounts_length_baseOffset = 0xc0; uint256 constant ConduitBatch1155Transfer_calldata_baseSize = 0xc0; // Note: abbreviated version of above constant to adhere to line length limit. uint256 constant ConduitBatchTransfer_amounts_head_offset = 0x80; uint256 constant Invalid1155BatchTransferEncoding_ptr = 0x00; uint256 constant Invalid1155BatchTransferEncoding_length = 0x04; uint256 constant Invalid1155BatchTransferEncoding_selector = ( 0xeba2084c00000000000000000000000000000000000000000000000000000000 ); uint256 constant ERC1155BatchTransferGenericFailure_error_signature = ( 0xafc445e200000000000000000000000000000000000000000000000000000000 ); uint256 constant ERC1155BatchTransferGenericFailure_token_ptr = 0x04; uint256 constant ERC1155BatchTransferGenericFailure_ids_offset = 0xc0;
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; /** * @title TokenTransferrerErrors */ interface TokenTransferrerErrors { /** * @dev Revert with an error when an ERC721 transfer with amount other than * one is attempted. */ error InvalidERC721TransferAmount(); /** * @dev Revert with an error when attempting to fulfill an order where an * item has an amount of zero. */ error MissingItemAmount(); /** * @dev Revert with an error when attempting to fulfill an order where an * item has unused parameters. This includes both the token and the * identifier parameters for native transfers as well as the identifier * parameter for ERC20 transfers. Note that the conduit does not * perform this check, leaving it up to the calling channel to enforce * when desired. */ error UnusedItemParameters(); /** * @dev Revert with an error when an ERC20, ERC721, or ERC1155 token * transfer reverts. * * @param token The token for which the transfer was attempted. * @param from The source of the attempted transfer. * @param to The recipient of the attempted transfer. * @param identifier The identifier for the attempted transfer. * @param amount The amount for the attempted transfer. */ error TokenTransferGenericFailure( address token, address from, address to, uint256 identifier, uint256 amount ); /** * @dev Revert with an error when a batch ERC1155 token transfer reverts. * * @param token The token for which the transfer was attempted. * @param from The source of the attempted transfer. * @param to The recipient of the attempted transfer. * @param identifiers The identifiers for the attempted transfer. * @param amounts The amounts for the attempted transfer. */ error ERC1155BatchTransferGenericFailure( address token, address from, address to, uint256[] identifiers, uint256[] amounts ); /** * @dev Revert with an error when an ERC20 token transfer returns a falsey * value. * * @param token The token for which the ERC20 transfer was attempted. * @param from The source of the attempted ERC20 transfer. * @param to The recipient of the attempted ERC20 transfer. * @param amount The amount for the attempted ERC20 transfer. */ error BadReturnValueFromERC20OnTransfer( address token, address from, address to, uint256 amount ); /** * @dev Revert with an error when an account being called as an assumed * contract does not have code and returns no data. * * @param account The account that should contain code. */ error NoContract(address account); /** * @dev Revert with an error when attempting to execute an 1155 batch * transfer using calldata not produced by default ABI encoding or with * different lengths for ids and amounts arrays. */ error Invalid1155BatchTransferEncoding(); }
{ "viaIR": true, "optimizer": { "enabled": true, "runs": 1000000 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
Contract ABI
[{"inputs":[{"internalType":"address","name":"conduitController","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"bytes","name":"reason","type":"bytes"},{"internalType":"bytes32","name":"conduitKey","type":"bytes32"},{"internalType":"address","name":"conduit","type":"address"}],"name":"ConduitErrorRevertBytes","type":"error"},{"inputs":[{"internalType":"string","name":"reason","type":"string"},{"internalType":"bytes32","name":"conduitKey","type":"bytes32"},{"internalType":"address","name":"conduit","type":"address"}],"name":"ConduitErrorRevertString","type":"error"},{"inputs":[{"internalType":"bytes","name":"reason","type":"bytes"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"identifier","type":"uint256"}],"name":"ERC721ReceiverErrorRevertBytes","type":"error"},{"inputs":[{"internalType":"string","name":"reason","type":"string"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"identifier","type":"uint256"}],"name":"ERC721ReceiverErrorRevertString","type":"error"},{"inputs":[{"internalType":"bytes32","name":"conduitKey","type":"bytes32"},{"internalType":"address","name":"conduit","type":"address"}],"name":"InvalidConduit","type":"error"},{"inputs":[],"name":"InvalidERC20Identifier","type":"error"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"InvalidERC721Recipient","type":"error"},{"inputs":[],"name":"InvalidERC721TransferAmount","type":"error"},{"inputs":[],"name":"InvalidItemType","type":"error"},{"inputs":[],"name":"RecipientCannotBeZeroAddress","type":"error"},{"inputs":[{"components":[{"components":[{"internalType":"enum ConduitItemType","name":"itemType","type":"uint8"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"identifier","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct TransferHelperItem[]","name":"items","type":"tuple[]"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"bool","name":"validateERC721Receiver","type":"bool"}],"internalType":"struct TransferHelperItemsWithRecipient[]","name":"items","type":"tuple[]"},{"internalType":"bytes32","name":"conduitKey","type":"bytes32"}],"name":"bulkTransfer","outputs":[{"internalType":"bytes4","name":"magicValue","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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 Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000000000000f9490004c11cef243f5400493c00ad63
-----Decoded View---------------
Arg [0] : conduitController (address): 0x00000000F9490004C11Cef243f5400493c00Ad63
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000f9490004c11cef243f5400493c00ad63Loading...LoadingLoading...Loading
Loading...Loading
Loading...LoadingLoading...LoadingLoading...LoadingLoading...LoadingLoading...Loading[ Download: CSV Export ][ Download: CSV Export ]A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.
Address QR Code
My Address - Private Name Tag or Note
My Name Tag:
Private Name Tags (up to 35 characters) can be used for easy identification of addressesPrivate Note:
A private note (up to 500 characters) can be attached to this address.
Please DO NOT store any passwords or private keys here.Compiler specific version warnings:
The compiled contract might be susceptible to VerbatimInvalidDeduplication (low-severity), FullInlinerNonExpressionSplitArgumentEvaluationOrder (low-severity), MissingSideEffectsOnSelectorAccess (low-severity), StorageWriteRemovalBeforeConditionalTermination (medium/high-severity) Solidity Compiler Bugs.
Connect a Wallet
Connecting wallet for read function is optional, useful if you want to call certain functions or simply use your wallet's node.Connect a Wallet
Connecting wallet for read function is optional, useful if you want to call certain functions or simply use your wallet's node.Connect a Wallet
Connecting wallet for read function is optional, useful if you want to call certain functions or simply use your wallet's node.Before You Copy
Transaction Private Note
This website uses cookies to improve your experience. By continuing to use this website, you agree to its Terms and Privacy Policy.