Feature Tip: Add private address tag to any address under My Name Tag !
Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 1,753 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Create Channel | 14087480 | 898 days ago | IN | 0 ETH | 0.0181674 | ||||
Create Channel A... | 13937840 | 921 days ago | IN | 0.09838097 ETH | 0.01964349 | ||||
Create Channel | 13935699 | 921 days ago | IN | 0 ETH | 0.01628693 | ||||
Create Channel | 13935693 | 921 days ago | IN | 0 ETH | 0.02156879 | ||||
Create Channel | 13935687 | 921 days ago | IN | 0 ETH | 0.0202247 | ||||
Create Channel A... | 13934919 | 921 days ago | IN | 0.08129597 ETH | 0.0259309 | ||||
Create Channel | 13766793 | 947 days ago | IN | 0 ETH | 0.01470637 | ||||
Create Channel | 13766779 | 947 days ago | IN | 0 ETH | 0.01664752 | ||||
Create Channel | 13598400 | 974 days ago | IN | 0 ETH | 0.03005102 | ||||
Create Channel | 13580666 | 977 days ago | IN | 0 ETH | 0.0248095 | ||||
Create Channel A... | 13476853 | 993 days ago | IN | 0 ETH | 0.01295841 | ||||
Create Channel | 13387449 | 1007 days ago | IN | 0 ETH | 0.01159496 | ||||
Create Channel A... | 13349551 | 1013 days ago | IN | 0 ETH | 0.01468292 | ||||
Create Channel A... | 13341579 | 1014 days ago | IN | 0 ETH | 0.01594192 | ||||
Create Channel A... | 13302124 | 1020 days ago | IN | 0 ETH | 0.01085084 | ||||
Create Channel | 13279338 | 1024 days ago | IN | 0 ETH | 0.01399865 | ||||
Create Channel | 13276947 | 1024 days ago | IN | 0 ETH | 0.01976377 | ||||
Create Channel | 13226702 | 1032 days ago | IN | 0 ETH | 0.01043905 | ||||
Create Channel A... | 13221262 | 1033 days ago | IN | 0 ETH | 0.0112114 | ||||
Create Channel | 13199116 | 1036 days ago | IN | 0 ETH | 0.01242301 | ||||
Create Channel | 13183609 | 1039 days ago | IN | 0 ETH | 0.01916006 | ||||
Create Channel | 13142017 | 1045 days ago | IN | 0 ETH | 0.02165523 | ||||
Create Channel A... | 13097311 | 1052 days ago | IN | 0 ETH | 0.02073677 | ||||
Create Channel | 13059614 | 1058 days ago | IN | 0 ETH | 0.00505772 | ||||
Create Channel | 13046660 | 1060 days ago | IN | 0 ETH | 0.00577855 |
Latest 25 internal transactions (View All)
Advanced mode:
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Name:
ChannelFactory
Compiler Version
v0.7.1+commit.f4a555be
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: UNLICENSED pragma solidity ^0.7.1; pragma experimental ABIEncoderV2; import "@openzeppelin/contracts/utils/Create2.sol"; import "./interfaces/IChannelFactory.sol"; import "./interfaces/IVectorChannel.sol"; import "./lib/LibAsset.sol"; import "./lib/LibERC20.sol"; /// @title ChannelFactory /// @author Connext <[email protected]> /// @notice Creates and sets up a new channel proxy contract contract ChannelFactory is IChannelFactory { // Creation code constants taken from EIP1167 bytes private constant proxyCreationCodePrefix = hex"3d602d80600a3d3981f3_363d3d373d3d3d363d73"; bytes private constant proxyCreationCodeSuffix = hex"5af43d82803e903d91602b57fd5bf3"; bytes32 private creationCodeHash; address private immutable mastercopy; uint256 private immutable chainId; /// @dev Creates a new `ChannelFactory` /// @param _mastercopy the address of the `ChannelMastercopy` (channel logic) /// @param _chainId the chain identifier when generating the CREATE2 salt. If zero, the chain identifier used in the proxy salt will be the result of the opcode constructor(address _mastercopy, uint256 _chainId) { mastercopy = _mastercopy; chainId = _chainId; creationCodeHash = keccak256(_getProxyCreationCode(_mastercopy)); } //////////////////////////////////////// // Public Methods /// @dev Allows us to get the mastercopy that this factory will deploy channels against function getMastercopy() external view override returns (address) { return mastercopy; } /// @dev Allows us to get the chainId that this factory will use in the create2 salt function getChainId() public view override returns (uint256 _chainId) { // Hold in memory to reduce sload calls uint256 chain = chainId; if (chain == 0) { assembly { _chainId := chainid() } } else { _chainId = chain; } } /// @dev Allows us to get the chainId that this factory has stored function getStoredChainId() external view override returns (uint256) { return chainId; } /// @dev Returns the proxy code used to both calculate the CREATE2 address and deploy the channel proxy pointed to the `ChannelMastercopy` function getProxyCreationCode() public view override returns (bytes memory) { return _getProxyCreationCode(mastercopy); } /// @dev Allows us to get the address for a new channel contract created via `createChannel` /// @param alice address of the igh fidelity channel participant /// @param bob address of the other channel participant function getChannelAddress(address alice, address bob) external view override returns (address) { return Create2.computeAddress( generateSalt(alice, bob), creationCodeHash ); } /// @dev Allows us to create new channel contract and get it all set up in one transaction /// @param alice address of the high fidelity channel participant /// @param bob address of the other channel participant function createChannel(address alice, address bob) public override returns (address channel) { channel = deployChannelProxy(alice, bob); IVectorChannel(channel).setup(alice, bob); emit ChannelCreation(channel); } /// @dev Allows us to create a new channel contract and fund it in one transaction /// @param bob address of the other channel participant function createChannelAndDepositAlice( address alice, address bob, address assetId, uint256 amount ) external payable override returns (address channel) { channel = createChannel(alice, bob); // Deposit funds (if a token) must be approved for the // `ChannelFactory`, which then claims the funds and transfers // to the channel address. While this is inefficient, this is // the safest/clearest way to transfer funds if (!LibAsset.isEther(assetId)) { require( LibERC20.transferFrom( assetId, msg.sender, address(this), amount ), "ChannelFactory: ERC20_TRANSFER_FAILED" ); require( LibERC20.approve(assetId, address(channel), amount), "ChannelFactory: ERC20_APPROVE_FAILED" ); } IVectorChannel(channel).depositAlice{value: msg.value}(assetId, amount); } //////////////////////////////////////// // Internal Methods function _getProxyCreationCode(address _mastercopy) internal pure returns (bytes memory) { return abi.encodePacked( proxyCreationCodePrefix, _mastercopy, proxyCreationCodeSuffix ); } /// @dev Allows us to create new channel contact using CREATE2 /// @param alice address of the high fidelity participant in the channel /// @param bob address of the other channel participant function deployChannelProxy(address alice, address bob) internal returns (address) { bytes32 salt = generateSalt(alice, bob); return Create2.deploy(0, salt, getProxyCreationCode()); } /// @dev Generates the unique salt for calculating the CREATE2 address of the channel proxy function generateSalt(address alice, address bob) internal view returns (bytes32) { return keccak256(abi.encodePacked(alice, bob, getChainId())); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.7.0; /** * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer. * `CREATE2` can be used to compute in advance the address where a smart * contract will be deployed, which allows for interesting new mechanisms known * as 'counterfactual interactions'. * * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more * information. */ library Create2 { /** * @dev Deploys a contract using `CREATE2`. The address where the contract * will be deployed can be known in advance via {computeAddress}. * * The bytecode for a contract can be obtained from Solidity with * `type(contractName).creationCode`. * * Requirements: * * - `bytecode` must not be empty. * - `salt` must have not been used for `bytecode` already. * - the factory must have a balance of at least `amount`. * - if `amount` is non-zero, `bytecode` must have a `payable` constructor. */ function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address) { address addr; require(address(this).balance >= amount, "Create2: insufficient balance"); require(bytecode.length != 0, "Create2: bytecode length is zero"); // solhint-disable-next-line no-inline-assembly assembly { addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt) } require(addr != address(0), "Create2: Failed on deploy"); return addr; } /** * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the * `bytecodeHash` or `salt` will result in a new destination address. */ function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) { return computeAddress(salt, bytecodeHash, address(this)); } /** * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}. */ function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address) { bytes32 _data = keccak256( abi.encodePacked(bytes1(0xff), deployer, salt, bytecodeHash) ); return address(uint256(_data)); } }
// SPDX-License-Identifier: UNLICENSED pragma solidity ^0.7.1; pragma experimental ABIEncoderV2; interface IChannelFactory { event ChannelCreation(address channel); function getMastercopy() external view returns (address); function getChainId() external view returns (uint256); function getStoredChainId() external view returns (uint256); function getProxyCreationCode() external view returns (bytes memory); function getChannelAddress(address alice, address bob) external view returns (address); function createChannel(address alice, address bob) external returns (address); function createChannelAndDepositAlice( address alice, address bob, address assetId, uint256 amount ) external payable returns (address); }
// SPDX-License-Identifier: UNLICENSED pragma solidity ^0.7.1; pragma experimental ABIEncoderV2; import "./ICMCCore.sol"; import "./ICMCAsset.sol"; import "./ICMCDeposit.sol"; import "./ICMCWithdraw.sol"; import "./ICMCAdjudicator.sol"; interface IVectorChannel is ICMCCore, ICMCAsset, ICMCDeposit, ICMCWithdraw, ICMCAdjudicator {}
// SPDX-License-Identifier: UNLICENSED pragma solidity ^0.7.1; pragma experimental ABIEncoderV2; import "./LibERC20.sol"; import "./LibUtils.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; /// @title LibAsset /// @author Connext <[email protected]> /// @notice This library contains helpers for dealing with onchain transfers /// of in-channel assets. It is designed to safely handle all asset /// transfers out of channel in the event of an onchain dispute. Also /// safely handles ERC20 transfers that may be non-compliant library LibAsset { address constant ETHER_ASSETID = address(0); function isEther(address assetId) internal pure returns (bool) { return assetId == ETHER_ASSETID; } function getOwnBalance(address assetId) internal view returns (uint256) { return isEther(assetId) ? address(this).balance : IERC20(assetId).balanceOf(address(this)); } function transferEther(address payable recipient, uint256 amount) internal returns (bool) { (bool success, bytes memory returnData) = recipient.call{value: amount}(""); LibUtils.revertIfCallFailed(success, returnData); return true; } function transferERC20( address assetId, address recipient, uint256 amount ) internal returns (bool) { return LibERC20.transfer(assetId, recipient, amount); } // This function is a wrapper for transfers of Ether or ERC20 tokens, // both standard-compliant ones as well as tokens that exhibit the // missing-return-value bug. // Although it behaves very much like Solidity's `transfer` function // or the ERC20 `transfer` and is, in fact, designed to replace direct // usage of those, it is deliberately named `unregisteredTransfer`, // because we need to register every transfer out of the channel. // Therefore, it should normally not be used directly, with the single // exception of the `transferAsset` function in `CMCAsset.sol`, // which combines the "naked" unregistered transfer given below // with a registration. // USING THIS FUNCTION SOMEWHERE ELSE IS PROBABLY WRONG! function unregisteredTransfer( address assetId, address payable recipient, uint256 amount ) internal returns (bool) { return isEther(assetId) ? transferEther(recipient, amount) : transferERC20(assetId, recipient, amount); } }
// SPDX-License-Identifier: UNLICENSED pragma solidity ^0.7.1; pragma experimental ABIEncoderV2; import "./LibUtils.sol"; import "@openzeppelin/contracts/utils/Address.sol"; /// @title LibERC20 /// @author Connext <[email protected]> /// @notice This library provides several functions to safely handle /// noncompliant tokens (i.e. does not return a boolean from /// the transfer function) library LibERC20 { function wrapCall(address assetId, bytes memory callData) internal returns (bool) { require(Address.isContract(assetId), "LibERC20: NO_CODE"); (bool success, bytes memory returnData) = assetId.call(callData); LibUtils.revertIfCallFailed(success, returnData); return returnData.length == 0 || abi.decode(returnData, (bool)); } function approve( address assetId, address spender, uint256 amount ) internal returns (bool) { return wrapCall( assetId, abi.encodeWithSignature( "approve(address,uint256)", spender, amount ) ); } function transferFrom( address assetId, address sender, address recipient, uint256 amount ) internal returns (bool) { return wrapCall( assetId, abi.encodeWithSignature( "transferFrom(address,address,uint256)", sender, recipient, amount ) ); } function transfer( address assetId, address recipient, uint256 amount ) internal returns (bool) { return wrapCall( assetId, abi.encodeWithSignature( "transfer(address,uint256)", recipient, amount ) ); } }
// SPDX-License-Identifier: UNLICENSED pragma solidity ^0.7.1; pragma experimental ABIEncoderV2; interface ICMCCore { function setup(address _alice, address _bob) external; function getAlice() external view returns (address); function getBob() external view returns (address); }
// SPDX-License-Identifier: UNLICENSED pragma solidity ^0.7.1; pragma experimental ABIEncoderV2; interface ICMCAsset { function getTotalTransferred(address assetId) external view returns (uint256); function getExitableAmount(address assetId, address owner) external view returns (uint256); function exit( address assetId, address owner, address payable recipient ) external; }
// SPDX-License-Identifier: UNLICENSED pragma solidity ^0.7.1; pragma experimental ABIEncoderV2; interface ICMCDeposit { event AliceDeposited(address assetId, uint256 amount); function getTotalDepositsAlice(address assetId) external view returns (uint256); function getTotalDepositsBob(address assetId) external view returns (uint256); function depositAlice(address assetId, uint256 amount) external payable; }
// SPDX-License-Identifier: UNLICENSED pragma solidity ^0.7.1; pragma experimental ABIEncoderV2; struct WithdrawData { address channelAddress; address assetId; address payable recipient; uint256 amount; uint256 nonce; address callTo; bytes callData; } interface ICMCWithdraw { function getWithdrawalTransactionRecord(WithdrawData calldata wd) external view returns (bool); function withdraw( WithdrawData calldata wd, bytes calldata aliceSignature, bytes calldata bobSignature ) external; }
// SPDX-License-Identifier: UNLICENSED pragma solidity ^0.7.1; pragma experimental ABIEncoderV2; import "./Types.sol"; interface ICMCAdjudicator { struct CoreChannelState { address channelAddress; address alice; address bob; address[] assetIds; Balance[] balances; uint256[] processedDepositsA; uint256[] processedDepositsB; uint256[] defundNonces; uint256 timeout; uint256 nonce; bytes32 merkleRoot; } struct CoreTransferState { address channelAddress; bytes32 transferId; address transferDefinition; address initiator; address responder; address assetId; Balance balance; uint256 transferTimeout; bytes32 initialStateHash; } struct ChannelDispute { bytes32 channelStateHash; uint256 nonce; bytes32 merkleRoot; uint256 consensusExpiry; uint256 defundExpiry; } struct TransferDispute { bytes32 transferStateHash; uint256 transferDisputeExpiry; bool isDefunded; } event ChannelDisputed( address disputer, CoreChannelState state, ChannelDispute dispute ); event ChannelDefunded( address defunder, CoreChannelState state, ChannelDispute dispute, address[] assetIds ); event TransferDisputed( address disputer, CoreTransferState state, TransferDispute dispute ); event TransferDefunded( address defunder, CoreTransferState state, TransferDispute dispute, bytes encodedInitialState, bytes encodedResolver, Balance balance ); function getChannelDispute() external view returns (ChannelDispute memory); function getDefundNonce(address assetId) external view returns (uint256); function getTransferDispute(bytes32 transferId) external view returns (TransferDispute memory); function disputeChannel( CoreChannelState calldata ccs, bytes calldata aliceSignature, bytes calldata bobSignature ) external; function defundChannel( CoreChannelState calldata ccs, address[] calldata assetIds, uint256[] calldata indices ) external; function disputeTransfer( CoreTransferState calldata cts, bytes32[] calldata merkleProofData ) external; function defundTransfer( CoreTransferState calldata cts, bytes calldata encodedInitialTransferState, bytes calldata encodedTransferResolver, bytes calldata responderSignature ) external; }
// SPDX-License-Identifier: UNLICENSED pragma solidity ^0.7.1; pragma experimental ABIEncoderV2; struct Balance { uint256[2] amount; // [alice, bob] in channel, [initiator, responder] in transfer address payable[2] to; // [alice, bob] in channel, [initiator, responder] in transfer }
// SPDX-License-Identifier: UNLICENSED pragma solidity ^0.7.1; pragma experimental ABIEncoderV2; /// @title LibUtils /// @author Connext <[email protected]> /// @notice Contains a helper to revert if a call was not successfully /// made library LibUtils { // If success is false, reverts and passes on the revert string. function revertIfCallFailed(bool success, bytes memory returnData) internal pure { if (!success) { assembly { revert(add(returnData, 0x20), mload(returnData)) } } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.7.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); }
// SPDX-License-Identifier: MIT pragma solidity ^0.7.0; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
{ "optimizer": { "enabled": true, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } }, "metadata": { "useLiteralContent": true } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_mastercopy","type":"address"},{"internalType":"uint256","name":"_chainId","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"channel","type":"address"}],"name":"ChannelCreation","type":"event"},{"inputs":[{"internalType":"address","name":"alice","type":"address"},{"internalType":"address","name":"bob","type":"address"}],"name":"createChannel","outputs":[{"internalType":"address","name":"channel","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"alice","type":"address"},{"internalType":"address","name":"bob","type":"address"},{"internalType":"address","name":"assetId","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"createChannelAndDepositAlice","outputs":[{"internalType":"address","name":"channel","type":"address"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"getChainId","outputs":[{"internalType":"uint256","name":"_chainId","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"alice","type":"address"},{"internalType":"address","name":"bob","type":"address"}],"name":"getChannelAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMastercopy","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getProxyCreationCode","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getStoredChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000d105b6b42206dfa6db00e6a4823bc88efac004760000000000000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : _mastercopy (address): 0xd105b6B42206dfA6Db00E6a4823bC88eFAC00476
Arg [1] : _chainId (uint256): 0
-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000d105b6b42206dfa6db00e6a4823bc88efac00476
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000000
Deployed Bytecode Sourcemap
428:5364:3:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2343:169;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2094:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;1701:316::-;;;;;;;;;;;;;:::i;3255:268::-;;;;;;;;;;-1:-1:-1;3255:268:3;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;2744:280::-;;;;;;;;;;-1:-1:-1;2744:280:3;;;;;:::i;:::-;;:::i;1506:100::-;;;;;;;;;;;;;:::i;3676:1064::-;;;;;;:::i;:::-;;:::i;2343:169::-;2437:12;2472:33;2494:10;2472:21;:33::i;:::-;2465:40;;2343:169;:::o;2094:100::-;2180:7;2094:100;:::o;1701:316::-;1753:16;1845:7;1866:10;1862:149;;1931:9;1919:21;;1901:53;;;1995:5;1984:16;;1862:149;1701:316;;:::o;3255:268::-;3355:15;3396:30;3415:5;3422:3;3396:18;:30::i;:::-;3436:41;;-1:-1:-1;;;3436:41:3;;3386:40;;-1:-1:-1;;;;;;3436:29:3;;;;;:41;;3466:5;;3473:3;;3436:41;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3492:24;3508:7;3492:24;;;;;;:::i;:::-;;;;;;;;3255:268;;;;:::o;2744:280::-;2863:7;2905:112;2945:24;2958:5;2965:3;2945:12;:24::i;:::-;2987:16;;2905:22;:112::i;:::-;2886:131;;2744:280;;;;;:::o;1506:100::-;1589:10;1506:100;:::o;3676:1064::-;3848:15;3885:25;3899:5;3906:3;3885:13;:25::i;:::-;3875:35;;4182:25;4199:7;4182:16;:25::i;:::-;4177:476;;4248:163;4291:7;4320:10;4360:4;4387:6;4248:21;:163::i;:::-;4223:259;;;;-1:-1:-1;;;4223:259:3;;;;;;;:::i;:::-;;;;;;;;;4521:51;4538:7;4555;4565:6;4521:16;:51::i;:::-;4496:146;;;;-1:-1:-1;;;4496:146:3;;;;;;;:::i;:::-;4662:71;;-1:-1:-1;;;4662:71:3;;-1:-1:-1;;;;;4662:36:3;;;;;4706:9;;4662:71;;4717:7;;4726:6;;4662:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3676:1064;;;;;;:::o;4816:252::-;4891:12;4954:23;;;;;;;;;;;;;-1:-1:-1;;;4954:23:3;;;4995:11;5024:23;;;;;;;;;;;;;-1:-1:-1;;;5024:23:3;;;4920:141;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;4913:148;;4816:252;;;:::o;5278:223::-;5368:7;5391:12;5406:24;5419:5;5426:3;5406:12;:24::i;:::-;5391:39;;5447:47;5462:1;5465:4;5471:22;:20;:22::i;:::-;5447:14;:47::i;:::-;5440:54;5278:223;-1:-1:-1;;;;5278:223:3:o;5603:187::-;5700:7;5757:5;5764:3;5769:12;:10;:12::i;:::-;5740:42;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;5730:53;;;;;;5723:60;;5603:187;;;;:::o;1752:165:2:-;1835:7;1861:49;1876:4;1882:12;1904:4;1861:14;:49::i;646:111:12:-;-1:-1:-1;;;;;726:24:12;;;646:111::o;1200:442:13:-;1346:4;1381:254;1407:7;1538:6;1566:9;1597:6;1432:189;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;1432:189:13;;;;;;;;;;;;;;-1:-1:-1;;;;;1432:189:13;-1:-1:-1;;;1432:189:13;;;1381:8;:254::i;:::-;1362:273;1200:442;-1:-1:-1;;;;;1200:442:13:o;826:368::-;941:4;976:211;1002:7;1120;1149:6;1027:146;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;1027:146:13;;;;;;;;;;;;;;-1:-1:-1;;;;;1027:146:13;-1:-1:-1;;;1027:146:13;;;976:8;:211::i;1013:535:2:-;1100:7;1119:12;1174:6;1149:21;:31;;1141:73;;;;-1:-1:-1;;;1141:73:2;;;;;;;:::i;:::-;1232:15;;1224:65;;;;-1:-1:-1;;;1224:65:2;;;;;;;:::i;:::-;1440:4;1429:8;1423:15;1416:4;1406:8;1402:19;1394:6;1386:59;1378:67;-1:-1:-1;;;;;;1472:18:2;;1464:56;;;;-1:-1:-1;;;1464:56:2;;;;;;;:::i;2160:276::-;2261:7;2280:13;2343:4;2336:12;;2350:8;2360:4;2366:12;2319:60;;;;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1;;2319:60:2;;;;;;2296:93;;2319:60;2296:93;;;;;2160:276;-1:-1:-1;;;;;2160:276:2:o;439:381:13:-;531:4;559:27;578:7;559:18;:27::i;:::-;551:57;;;;-1:-1:-1;;;551:57:13;;;;;;;:::i;:::-;619:12;633:23;660:7;-1:-1:-1;;;;;660:12:13;673:8;660:22;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;618:64;;;;692:48;720:7;729:10;692:27;:48::i;:::-;757:17;;:22;;:56;;;794:10;783:30;;;;;;;;;;;;:::i;718:610:1:-;778:4;1239:20;;1084:66;1278:23;;;;;;:42;;-1:-1:-1;;1305:15:1;;;1270:51;-1:-1:-1;;718:610:1:o;344:244:14:-;460:7;455:127;;546:10;540:17;533:4;521:10;517:21;510:48;492:80;344:244;;:::o;5:130:-1:-;72:20;;-1:-1;;;;;12972:54;;14100:35;;14090:2;;14149:1;;14139:12;414:366;;;535:2;523:9;514:7;510:23;506:32;503:2;;;-1:-1;;541:12;503:2;603:53;648:7;624:22;603:53;:::i;:::-;593:63;;711:53;756:7;693:2;736:9;732:22;711:53;:::i;:::-;701:63;;497:283;;;;;:::o;787:617::-;;;;;942:3;930:9;921:7;917:23;913:33;910:2;;;-1:-1;;949:12;910:2;1011:53;1056:7;1032:22;1011:53;:::i;:::-;1001:63;;1119:53;1164:7;1101:2;1144:9;1140:22;1119:53;:::i;:::-;1109:63;;1227:53;1272:7;1209:2;1252:9;1248:22;1227:53;:::i;:::-;904:500;;;;-1:-1;1217:63;;1317:2;1356:22;344:20;;-1:-1;;904:500::o;1411:257::-;;1523:2;1511:9;1502:7;1498:23;1494:32;1491:2;;;-1:-1;;1529:12;1491:2;223:6;217:13;14246:5;12654:13;12647:21;14224:5;14221:32;14211:2;;-1:-1;;14257:12;14211:2;1581:71;1485:183;-1:-1;;;1485:183::o;5364:531::-;-1:-1;;;;;;14013:2;14009:14;;;;;1884:58;;14009:14;;;;;;;5645:2;5636:12;;1884:58;5747:12;;;2198:58;5858:12;;;5536:359::o;5902:665::-;-1:-1;;;;;;12741:78;;;;2041:56;;14013:2;14009:14;;;;-1:-1;;;;;;14009:14;6207:1;6198:11;;1884:58;6308:12;;;2198:58;6419:12;;;2198:58;6530:12;;;6100:467::o;6574:271::-;;2778:5;11953:12;2889:52;2934:6;2929:3;2922:4;2915:5;2911:16;2889:52;:::i;:::-;2953:16;;;;;6708:137;-1:-1;;6708:137::o;6852:567::-;;2778:5;11953:12;2889:52;2934:6;2929:3;2922:4;2915:5;2911:16;2889:52;:::i;:::-;14013:2;14009:14;;;-1:-1;;;;;;14009:14;2953:16;;;1884:58;;;11953:12;;2889:52;11953:12;7280:2;7271:12;;2922:4;2911:16;;2889:52;:::i;:::-;2953:16;7280:2;2953:16;;7060:359;-1:-1;;;;;7060:359::o;7426:222::-;-1:-1;;;;;12972:54;;;;1746:37;;7553:2;7538:18;;7524:124::o;7655:333::-;-1:-1;;;;;12972:54;;;1746:37;;12972:54;;7974:2;7959:18;;1746:37;7810:2;7795:18;;7781:207::o;7995:444::-;-1:-1;;;;;12972:54;;;1746:37;;12972:54;;;;8342:2;8327:18;;1746:37;8425:2;8410:18;;2198:58;;;;8178:2;8163:18;;8149:290::o;8446:333::-;-1:-1;;;;;12972:54;;;;1746:37;;8765:2;8750:18;;2198:58;8601:2;8586:18;;8572:207::o;8786:306::-;;8931:2;8952:17;8945:47;2410:5;11953:12;12109:6;8931:2;8920:9;8916:18;12097:19;2503:52;2548:6;12137:14;8920:9;12137:14;8931:2;2529:5;2525:16;2503:52;:::i;:::-;13918:7;13902:14;-1:-1;;13898:28;2567:39;;;;12137:14;2567:39;;8902:190;-1:-1;;8902:190::o;9099:416::-;9299:2;9313:47;;;9284:18;;;12097:19;3242:34;12137:14;;;3222:55;3296:12;;;9270:245::o;9522:416::-;9722:2;9736:47;;;3547:2;9707:18;;;12097:19;3583:27;12137:14;;;3563:48;3630:12;;;9693:245::o;9945:416::-;10145:2;10159:47;;;3881:2;10130:18;;;12097:19;-1:-1;;;12137:14;;;3897:40;3956:12;;;10116:245::o;10368:416::-;10568:2;10582:47;;;4207:2;10553:18;;;12097:19;4243:34;12137:14;;;4223:55;-1:-1;;;4298:12;;;4291:28;4338:12;;;10539:245::o;10791:416::-;10991:2;11005:47;;;4589:2;10976:18;;;12097:19;4625:34;12137:14;;;4605:55;-1:-1;;;4680:12;;;4673:29;4721:12;;;10962:245::o;11214:416::-;11414:2;11428:47;;;4972:2;11399:18;;;12097:19;5008:31;12137:14;;;4988:52;5059:12;;;11385:245::o;11637:222::-;2198:58;;;11764:2;11749:18;;11735:124::o;13118:268::-;13183:1;13190:101;13204:6;13201:1;13198:13;13190:101;;;13271:11;;;13265:18;13252:11;;;13245:39;13226:2;13219:10;13190:101;;;13306:6;13303:1;13300:13;13297:2;;;13183:1;13362:6;13357:3;13353:16;13346:27;13297:2;;13167:219;;;:::o
Swarm Source
ipfs://6b46714e4e157ca4fcef5f14f882cae62cdcfb5e301602c8361ab37a1daaf2ab
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
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.