0x75deb70b…6127sent to0xb2b01dec…c525·#19,242,701·view on Etherscan
UOdata:application/vnd.facet.tx+json;rule=esip6,{"op":"call","data":{"to":"0xc59dec74518c6c86b90107c3644ac9daca149e70","function":"upgrade","args":{"newHash":"0xee18008875b9e2ecadebb7566928a6a853a23f15c2393221f6a9db8d81fd5670","newSource":"pragma(:rubidity, \"1.0.0\")\ncontract(:ERC20, abstract: true) {\n event(:Transfer, { from: :address, to: :address, amount: :uint256 })\n event(:Approval, { owner: :address, spender: :address, amount: :uint256 })\n string(:public, :name)\n string(:public, :symbol)\n uint8(:public, :decimals)\n uint256(:public, :totalSupply)\n mapping(({ address: :uint256 }), :public, :balanceOf)\n mapping(({ address: mapping(address: :uint256) }), :public, :allowance)\n constructor(name: :string, symbol: :string, decimals: :uint8) {\n s.name=name\n s.symbol=symbol\n s.decimals=decimals\n }\n function(:approve, { spender: :address, amount: :uint256 }, :public, :virtual, returns: :bool) {\n s.allowance[msg.sender][spender] = amount\n emit(:Approval, owner: msg.sender, spender: spender, amount: amount)\n return true\n }\n function(:transfer, { to: :address, amount: :uint256 }, :public, :virtual, returns: :bool) {\n require(s.balanceOf[msg.sender] \u003e= amount, \"Insufficient balance\")\n s.balanceOf[msg.sender] -= amount\n s.balanceOf[to] += amount\n emit(:Transfer, from: msg.sender, to: to, amount: amount)\n return true\n }\n function(:transferFrom, { from: :address, to: :address, amount: :uint256 }, :public, :virtual, returns: :bool) {\n allowed = s.allowance[from][msg.sender]\n require(s.balanceOf[from] \u003e= amount, \"Insufficient balance\")\n require(allowed \u003e= amount, \"Insufficient allowance\")\n s.allowance[from][msg.sender] = allowed - amount\n s.balanceOf[from] -= amount\n s.balanceOf[to] += amount\n emit(:Transfer, from: from, to: to, amount: amount)\n return true\n }\n function(:_mint, { to: :address, amount: :uint256 }, :internal, :virtual) {\n s.totalSupply += amount\n s.balanceOf[to] += amount\n emit(:Transfer, from: address(0), to: to, amount: amount)\n }\n function(:_burn, { from: :address, amount: :uint256 }, :internal, :virtual) {\n require(s.balanceOf[from] \u003e= amount, \"Insufficient balance\")\n s.balanceOf[from] -= amount\n s.totalSupply -= amount\n emit(:Transfer, from: from, to: address(0), amount: amount)\n }\n}\ncontract(:ERC2981, abstract: true) {\n event(:DefaultRoyaltyUpdated, { receiver: :address, feeNumerator: :uint96 })\n event(:TokenRoyaltyUpdated, { tokenId: :uint256, receiver: :address, feeNumerator: :uint96 })\n mapping(({ uint256: :address }), :internal, :_tokenIdToReceiver)\n mapping(({ uint256: :uint96 }), :internal, :_tokenIdToFeeNumerator)\n address(:internal, :_defaultRoyaltyReceiver)\n uint96(:internal, :_defaultFeeNumerator)\n function(:royaltyInfo, { tokenId: :uint256, salePrice: :uint256 }, :public, :view, :virtual, returns: { receiver: :address, royaltyAmount: :uint256 }) {\n receiver = s._tokenIdToReceiver[tokenId]\n feeNumerator = s._tokenIdToFeeNumerator[tokenId]\n if receiver == address(0)\n receiver = s._defaultRoyaltyReceiver\n feeNumerator = s._defaultFeeNumerator\n end\n royaltyAmount = (salePrice * feeNumerator).div(_feeDenominator)\n return { receiver: receiver, royaltyAmount: royaltyAmount }\n }\n function(:_setDefaultRoyalty, { receiver: :address, feeNumerator: :uint96 }, :internal, :virtual) {\n require(feeNumerator \u003c= _feeDenominator, \"ERC2981InvalidDefaultRoyalty\")\n require(receiver != address(0), \"ERC2981InvalidDefaultRoyaltyReceiver: address(0)\")\n s._defaultRoyaltyReceiver=receiver\n s._defaultFeeNumerator=feeNumerator\n emit(:DefaultRoyaltyUpdated, receiver: receiver, feeNumerator: feeNumerator)\n }\n function(:_deleteDefaultRoyalty, :internal, :virtual) {\n s._defaultRoyaltyReceiver=address(0)\n s._defaultFeeNumerator=0\n emit(:DefaultRoyaltyUpdated, receiver: address(0), feeNumerator: 0)\n }\n function(:_setTokenRoyalty, { tokenId: :uint256, receiver: :address, feeNumerator: :uint96 }, :internal, :virtual) {\n require(feeNumerator \u003c= _feeDenominator, \"ERC2981InvalidTokenRoyalty\")\n require(receiver != address(0), \"ERC2981InvalidTokenRoyaltyReceiver\")\n s._tokenIdToReceiver[tokenId] = receiver\n s._tokenIdToFeeNumerator[tokenId] = feeNumerator\n emit(:TokenRoyaltyUpdated, tokenId: tokenId, receiver: receiver, feeNumerator: feeNumerator)\n }\n function(:_deleteTokenRoyalty, { tokenId: :uint256 }, :internal, :virtual) {\n s._tokenIdToReceiver[tokenId] = address(0)\n s._tokenIdToFeeNumerator[tokenId] = 0\n emit(:TokenRoyaltyUpdated, tokenId: tokenId, receiver: address(0), feeNumerator: 0)\n }\n function(:_feeDenominator, :internal, :view, :virtual, returns: :uint96) {\n return 10000\n }\n function(:supportsERC2981, :public, :pure, :virtual, returns: :bool) {\n return true\n }\n}\ncontract(:ERC721, abstract: true) {\n event(:Transfer, { from: :address, to: :address, id: :uint256 })\n event(:Approval, { owner: :address, spender: :address, id: :uint256 })\n event(:ApprovalForAll, { owner: :address, operator: :address, approved: :bool })\n string(:public, :name)\n string(:public, :symbol)\n mapping(({ uint256: :address }), :internal, :_ownerOf)\n mapping(({ address: :uint256 }), :internal, :_balanceOf)\n mapping(({ uint256: :address }), :public, :getApproved)\n mapping(({ address: mapping(address: :bool) }), :public, :isApprovedForAll)\n constructor(name: :string, symbol: :string) {\n s.name=name\n s.symbol=symbol\n }\n function(:ownerOf, { id: :uint256 }, :public, :view, :virtual, returns: :address) {\n owner = s._ownerOf[id]\n require(owner != address(0), \"ERC721: owner query for nonexistent token\")\n return owner\n }\n function(:balanceOf, { owner: :address }, :public, :view, :virtual, returns: :uint256) {\n require(owner != address(0), \"ERC721: balance query for nonexistent owner\")\n return s._balanceOf[owner]\n }\n function(:approve, { spender: :address, id: :uint256 }, :public, :virtual) {\n owner = ownerOf(id)\n require(msg.sender == owner || s.isApprovedForAll[owner][msg.sender], \"ERC721: msg.sender not authorized to approve\")\n s.getApproved[id] = spender\n emit(:Approval, owner: owner, spender: spender, id: id)\n }\n function(:setApprovalForAll, { operator: :address, approved: :bool }, :public, :virtual) {\n s.isApprovedForAll[msg.sender][operator] = approved\n emit(:ApprovalForAll, owner: msg.sender, operator: operator, approved: approved)\n }\n function(:transferFrom, { from: :address, to: :address, id: :uint256 }, :public, :virtual) {\n require(from == ownerOf(id), \"ERC721: transfer of token that is not own\")\n require(to != address(0), \"ERC721: transfer to the zero address\")\n require(isApprovedOrOwner(spender: msg.sender, id: id), \"ERC721: msg.sender not authorized to call transferFrom\")\n s._balanceOf[from] -= 1\n s._balanceOf[to] += 1\n s._ownerOf[id] = to\n s.getApproved[id] = address(0)\n emit(:Transfer, from: from, to: to, id: id)\n }\n function(:isApprovedOrOwner, { spender: :address, id: :uint256 }, :public, :view, :virtual, returns: :bool) {\n owner = ownerOf(id)\n spender == owner || s.getApproved[id] == spender || s.isApprovedForAll[owner][spender]\n }\n function(:_exists, { id: :uint256 }, :internal, :view, :virtual, returns: :bool) {\n return s._ownerOf[id] != address(0)\n }\n function(:_mint, { to: :address, id: :uint256 }, :internal, :virtual) {\n require(to != address(0), \"ERC721: mint to the zero address\")\n require(s._ownerOf[id] == address(0), \"ERC721: token already minted\")\n s._balanceOf[to] += 1\n s._ownerOf[id] = to\n emit(:Transfer, from: address(0), to: to, id: id)\n }\n function(:_burn, { id: :uint256 }, :internal, :virtual) {\n owner = s._ownerOf[id]\n require(owner != address(0), \"ERC721: burn of nonexistent token\")\n s._balanceOf[owner] -= 1\n s._ownerOf[id] = address(0)\n s.getApproved[id] = address(0)\n emit(:Transfer, from: owner, to: address(0), id: id)\n }\n function(:tokenURI, { id: :uint256 }, :public, :view, :virtual, returns: :string) {\n }\n}\ncontract(:Ownable, abstract: true) {\n address(:public, :owner)\n event(:OwnershipTransferred, { previousOwner: :address, newOwner: :address })\n constructor(owner: :address) {\n s.owner=owner\n }\n function(:transferOwnership, { newOwner: :address }, :public) {\n onlyOwner!\n previousOwner = s.owner\n s.owner=newOwner\n emit(:OwnershipTransferred, previousOwner: previousOwner, newOwner: newOwner)\n }\n function(:onlyOwner!, :internal) {\n require(msg.sender == s.owner, \"msg.sender is not the owner\")\n }\n}\ncontract(:Pausable, abstract: true) {\n bool(:public, :paused)\n event(:Paused, { account: :address })\n event(:Unpaused, { account: :address })\n constructor(initialPauseState: :bool) {\n s.paused=initialPauseState\n }\n function(:_pause, :internal) {\n s.paused=true\n emit(:Paused, account: msg.sender)\n }\n function(:_unpause, :internal) {\n s.paused=false\n emit(:Unpaused, account: msg.sender)\n }\n function(:whenPaused!, :internal) {\n require(s.paused, \"Contract is not paused\")\n }\n function(:whenNotPaused!, :internal) {\n require(!s.paused, \"Contract is paused\")\n }\n}\ncontract(:Upgradeable, abstract: true) {\n address(:public, :upgradeAdmin)\n event(:ContractUpgraded, { oldHash: :bytes32, newHash: :bytes32 })\n event(:UpgradeAdminChanged, { newUpgradeAdmin: :address })\n constructor(upgradeAdmin: :address) {\n s.upgradeAdmin=upgradeAdmin\n }\n function(:setUpgradeAdmin, { newUpgradeAdmin: :address }, :public) {\n require(msg.sender == s.upgradeAdmin, \"NOT_AUTHORIZED\")\n s.upgradeAdmin=newUpgradeAdmin\n emit(:UpgradeAdminChanged, newUpgradeAdmin: newUpgradeAdmin)\n }\n function(:upgradeAndCall, { newHash: :bytes32, newSource: :string, migrationCalldata: :string }, :public) {\n upgrade(newHash: newHash, newSource: newSource)\n (success, data) = address(this).call(migrationCalldata)\n require(success, \"Migration failed\")\n }\n function(:upgrade, { newHash: :bytes32, newSource: :string }, :public) {\n currentHash = this.currentInitCodeHash\n require(msg.sender == s.upgradeAdmin, \"NOT_AUTHORIZED\")\n this.upgradeImplementation(newHash, newSource)\n emit(:ContractUpgraded, oldHash: currentHash, newHash: newHash)\n }\n}\ncontract(:FacetPortV101, is: [:Upgradeable, :Ownable, :Pausable], upgradeable: true) {\n event(:OfferAccepted, { success: :bool, offerType: :string, offerer: :address, buyer: :address, seller: :address, recipient: :address, assetContract: :address, assetId: :uint256, considerationAmount: :uint256, considerationToken: :address, offerId: :bytes16 })\n event(:OfferCancelled, { offerer: :address, offerId: :bytes16 })\n event(:AllOffersOnAssetCancelledForUser, { offerType: :string, offerer: :address, assetContract: :address, assetId: :uint256 })\n event(:AllOffersCancelledForUser, { offerType: :string, offerer: :address })\n mapping(({ address: mapping(bytes16: :bool) }), :public, :userOfferCancellations)\n mapping(({ string: mapping(address: mapping(address: mapping(uint256: :uint256))) }), :public, :userOffersOnAssetValidAfterTime)\n mapping(({ string: mapping(address: :uint256) }), :public, :userOffersValidAfterTime)\n uint96(:feeBps)\n constructor(_feeBps: :uint96, _upgradeAdmin: :address, _owner: :address) {\n s.feeBps=_feeBps\n self.Upgradeable.constructor(upgradeAdmin: _upgradeAdmin)\n self.Ownable.constructor(owner: _owner)\n _pause\n }\n function(:setFeeBps, { _feeBps: :uint96 }, :external) {\n onlyOwner!\n s.feeBps=_feeBps\n }\n function(:pause, :public) {\n onlyOwner!\n _pause\n }\n function(:unpause, :public) {\n onlyOwner!\n _unpause\n }\n function(:acceptOfferWithSignature, { offerType: :string, offerId: :bytes16, offerer: :address, recipient: :address, assetContract: :address, assetId: :uint256, assetType: :string, assetAmount: :uint256, considerationToken: :address, considerationAmount: :uint256, startTime: :uint256, endTime: :uint256, signature: :bytes }, :external) {\n success = _acceptOfferWithSignature(offerType: offerType, offerId: offerId, offerer: offerer, recipient: recipient, assetContract: assetContract, assetId: assetId, assetType: assetType, assetAmount: assetAmount, considerationToken: considerationToken, considerationAmount: considerationAmount, startTime: startTime, endTime: endTime, signature: signature)\n require(success, \"Offer was not successfully accepted\")\n }\n function(:acceptMultipleOffersWithSignatures, { offerTypes: [:string], offerIds: [:bytes16], offerers: [:address], recipients: [:address], assetContracts: [:address], assetIds: [:uint256], assetTypes: [:string], assetAmounts: [:uint256], considerationTokens: [:address], considerationAmounts: [:uint256], startTimes: [:uint256], endTimes: [:uint256], signatures: [:bytes] }, :external) {\n require(offerIds.length == offerers.length, \"Offer ID and offerer arrays must be the same length\")\n require(offerIds.length == offerTypes.length, \"Offer ID and offer types arrays must be the same length\")\n require(offerIds.length == assetContracts.length, \"Offer ID and asset contracts arrays must be the same length\")\n require(offerIds.length == assetIds.length, \"Offer ID and asset IDs arrays must be the same length\")\n require(offerIds.length == assetTypes.length, \"Offer ID and assetTypes arrays must be the same length\")\n require(offerIds.length == assetAmounts.length, \"Offer ID and assetAmounts arrays must be the same length\")\n require(offerIds.length == considerationTokens.length, \"Offer ID and consideration tokens arrays must be the same length\")\n require(offerIds.length == considerationAmounts.length, \"Offer ID and consideration amounts arrays must be the same length\")\n require(offerIds.length == startTimes.length, \"Offer ID and start times arrays must be the same length\")\n require(offerIds.length == endTimes.length, \"Offer ID and end times arrays must be the same length\")\n require(offerIds.length == signatures.length, \"Offer ID and signatures arrays must be the same length\")\n require(offerIds.length == recipients.length, \"Offer ID and recipients arrays must be the same length\")\n require(offerIds.length \u003c= 20, \"Cannot accept more than 20 offers at a time\")\n atLeastOneSuccess = false\n forLoop(condition: -\u003e(i) {\n i \u003c offerIds.length\n }) { |i|\n success = _acceptOfferWithSignature(offerType: offerTypes[i], offerId: offerIds[i], offerer: offerers[i], recipient: recipients[i], assetContract: assetContracts[i], assetId: assetIds[i], assetType: assetTypes[i], assetAmount: assetAmounts[i], considerationToken: considerationTokens[i], considerationAmount: considerationAmounts[i], startTime: startTimes[i], endTime: endTimes[i], signature: signatures[i])\n if success\n atLeastOneSuccess = true\n end\n }\n require(atLeastOneSuccess, \"No offers were successfully accepted\")\n }\n function(:_acceptOfferWithSignature, { offerType: :string, offerId: :bytes16, offerer: :address, recipient: :address, assetContract: :address, assetId: :uint256, assetType: :string, assetAmount: :uint256, considerationToken: :address, considerationAmount: :uint256, startTime: :uint256, endTime: :uint256, signature: :bytes }, :internal, returns: :bool) {\n whenNotPaused!\n signatureValid = signature.verifyTypedDataSignature({ Offer: [{ name: \"offerType\", type: \"string\" }, { name: \"offerId\", type: \"bytes16\" }, { name: \"offerer\", type: \"address\" }, { name: \"assetContract\", type: \"address\" }, { name: \"assetId\", type: \"uint256\" }, { name: \"assetType\", type: \"string\" }, { name: \"assetAmount\", type: \"uint256\" }, { name: \"considerationToken\", type: \"address\" }, { name: \"considerationAmount\", type: \"uint256\" }, { name: \"startTime\", type: \"uint256\" }, { name: \"endTime\", type: \"uint256\" }] }, { offerType: offerType, offerId: offerId, offerer: offerer, assetContract: assetContract, assetId: assetId, assetType: assetType, assetAmount: assetAmount, considerationToken: considerationToken, considerationAmount: considerationAmount, startTime: startTime, endTime: endTime }, verifyingContract: address(this), domainName: \"FacetPort\", domainVersion: \"1\", signer: offerer)\n require(signatureValid, \"Invalid signature\")\n require(!s.userOfferCancellations[offerer][offerId], \"Offer cancelled\")\n require(offerType == \"Listing\" || offerType == \"Bid\", \"Invalid offer type\")\n require(assetType == \"ERC721\" \u0026\u0026 assetAmount == 1, \"Only ERC721 assets are supported\")\n require(block.timestamp \u003e= startTime, \"Current time is before the start time\")\n require(block.timestamp \u003c endTime, \"Current time is after the end time\")\n require(startTime \u003e s.userOffersOnAssetValidAfterTime[offerType][offerer][assetContract][assetId], \"Start time is before the offerer's valid after time\")\n require(startTime \u003e s.userOffersValidAfterTime[offerType][offerer], \"Start time is before the valid after time for the offerer\")\n (buyer, seller) = if offerType == \"Bid\"\n [offerer, msg.sender]\n else\n [msg.sender, offerer]\n end\n transferSucceeded = _payRoyaltiesAndTransfer(assetContract: assetContract, assetId: assetId, seller: seller, buyer: buyer, recipient: recipient, considerationAmount: considerationAmount, considerationToken: considerationToken)\n emit(:OfferAccepted, { success: transferSucceeded, offerType: offerType, offerer: offerer, buyer: buyer, seller: seller, recipient: recipient, assetContract: assetContract, assetId: assetId, considerationAmount: considerationAmount, considerationToken: considerationToken, offerId: offerId })\n transferSucceeded\n }\n function(:_payRoyaltiesAndTransfer, { assetContract: :address, assetId: :uint256, seller: :address, buyer: :address, recipient: :address, considerationAmount: :uint256, considerationToken: :address }, :internal, returns: :bool) {\n require(recipient == address(0) || msg.sender == buyer, \"Only buyer can add recipient\")\n currentOwner = ERC721(assetContract).ownerOf(assetId)\n unless currentOwner == seller\n return false\n end\n (success, data) = assetContract.call(function: \"supportsERC2981\")\n royaltyAmount = 0\n if success \u0026\u0026 data == \"true\"\n (receiver, royaltyAmount) = ERC2981(assetContract).royaltyInfo(tokenId: assetId, salePrice: considerationAmount)\n if receiver == address(0)\n royaltyAmount = 0\n end\n if royaltyAmount \u003e 0\n ERC20(considerationToken).transferFrom(from: buyer, to: receiver, amount: royaltyAmount)\n end\n end\n marketplaceFee = computeFee(considerationAmount)\n sellerAmount = considerationAmount - royaltyAmount - marketplaceFee\n if sellerAmount \u003e 0\n ERC20(considerationToken).transferFrom(from: buyer, to: seller, amount: sellerAmount)\n end\n if marketplaceFee \u003e 0\n ERC20(considerationToken).transferFrom(from: buyer, to: owner, amount: marketplaceFee)\n end\n _transferNFT(assetContract: assetContract, assetId: assetId, recipient: if recipient == address(0)\n buyer\n else\n recipient\n end, from: seller)\n return true\n }\n function(:transferNFTs, { assetContracts: [:address], assetIds: [:uint256], recipients: [:address] }, :external) {\n require(assetContracts.length == assetIds.length, \"Asset contracts and asset IDs must be the same length\")\n require(assetContracts.length == recipients.length, \"Asset contracts and recipients must be the same length\")\n require(assetIds.length \u003c= 20, \"Cannot transfer more than 20 NFTs at a time\")\n forLoop(condition: -\u003e(i) {\n i \u003c recipients.length\n }) { |i|\n _transferNFT(assetContract: assetContracts[i], assetId: assetIds[i], recipient: recipients[i], from: msg.sender)\n }\n }\n function(:_transferNFT, { assetContract: :address, assetId: :uint256, recipient: :address, from: :address }, :internal) {\n whenNotPaused!\n ERC721(assetContract).transferFrom(from: from, to: recipient, id: assetId)\n s.userOffersOnAssetValidAfterTime[\"Listing\"][from][assetContract][assetId] = block.timestamp\n s.userOffersOnAssetValidAfterTime[\"Bid\"][recipient][assetContract][assetId] = block.timestamp\n nil\n }\n function(:cancelOffer, { offerId: :bytes16 }, :external) {\n s.userOfferCancellations[msg.sender][offerId] = true\n emit(:OfferCancelled, offerer: msg.sender, offerId: offerId)\n }\n function(:cancelAllOffersForAsset, { offerType: :string, assetContract: :address, assetId: :uint256 }, :external) {\n require(offerType == \"Listing\" || offerType == \"Bid\", \"Invalid offer type\")\n s.userOffersOnAssetValidAfterTime[offerType][msg.sender][assetContract][assetId] = block.timestamp\n emit(:AllOffersOnAssetCancelledForUser, offerType: offerType, offerer: msg.sender, assetContract: assetContract, assetId: assetId)\n }\n function(:cancelAllOffersOfUser, { offerType: :string }, :external) {\n require(offerType == \"Listing\" || offerType == \"Bid\", \"Invalid offer type\")\n s.userOffersValidAfterTime[offerType][msg.sender] = block.timestamp\n emit(:AllOffersCancelledForUser, offerType: offerType, offerer: msg.sender)\n }\n function(:computeFee, { amount: :uint256 }, :public, :view, returns: :uint256) {\n return (amount * s.feeBps).div(10000)\n }\n}\n"}}}