Small update

Publishing on blast now works
Added a few more scripts
Fixed the chain id bug

Author: GabrielCartier

foundry.toml

@@ -21,6 +21,8 @@ gas_reports = ["Echo"]
 # Config
 [rpc_endpoints]
 sepolia = "${SEPOLIA_RPC_URL}"
+blast_sepolia = "${BLAST_SEPOLIA_RPC_URL}"
 
 [etherscan]
-sepolia = { key = "${ETHERSCAN_API_KEY}" }
+sepolia = { key = "${ETHERSCAN_API_KEY}" }
+blast_sepolia = { key = "${BLASTSCAN_API_KEY}", url="https://api-sepolia.blastscan.io/api" }

script/DeployERC721.s.sol

@@ -9,13 +9,76 @@ contract DeployNFT is Script {
     function test() public {}
 
     function run() external {
-        vm.startBroadcast();
+        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
+        vm.startBroadcast(deployerPrivateKey);
 
-        Mocked721 YKPS = new Mocked721({name: "Kanpai Panda", symbol: "YKPS"});
-        YKPS.setBaseURI("https://prod.kanpaidev.com/api/token/");
+        address gab = address(0x213bE2f484Ab480db4f18b0Fe4C38e1C25877f09);
+        address jf = address(0x1E3918dD44F427F056be6C8E132cF1b5F42de59E);
 
-        Mocked721WithSuffix MAD = new Mocked721WithSuffix({name: "Mad Lads", symbol: "MAD"});
-        MAD.setBaseURI("https://madlads.s3.us-west-2.amazonaws.com/json/");
+        Mocked721WithSuffix CBC = new Mocked721WithSuffix({name: "Creepz by OVERLORD", symbol: "CBC"});
+        CBC.setBaseURI("ipfs://QmVRsXpYYp3qALoxjYUfNZAA6A28P86REKkoqadoXM5tLn/");
+
+        Mocked721 BAYC = new Mocked721({name: "BoredApeYachtClub", symbol: "BAYC"});
+        BAYC.setBaseURI("ipfs://QmeSjSinHpPnmXmspMjwiXyN6zS4E9zccariGR3jxcaWtq/");
+
+        Mocked721 SORA = new Mocked721({name: "Sora's Dreamworld", symbol: "Sora"});
+        SORA.setBaseURI("https://sorasdreamworld.io/tokens/");
+
+        Mocked721 MAYC = new Mocked721({name: "MutantApeYachtClub", symbol: "MAYC"});
+        MAYC.setBaseURI("https://boredapeyachtclub.com/api/mutants/");
+
+        // Mint NFTs
+        //CBC
+        CBC.safeMint(gab, 0);
+        CBC.safeMint(gab, 1);
+        CBC.safeMint(gab, 2);
+        CBC.safeMint(gab, 3);
+        CBC.safeMint(gab, 4);
+
+        CBC.safeMint(jf, 5);
+        CBC.safeMint(jf, 6);
+        CBC.safeMint(jf, 7);
+        CBC.safeMint(jf, 8);
+        CBC.safeMint(jf, 9);
+
+        // BAYC
+        BAYC.safeMint(gab, 0);
+        BAYC.safeMint(gab, 1);
+        BAYC.safeMint(gab, 2);
+        BAYC.safeMint(gab, 3);
+        BAYC.safeMint(gab, 4);
+
+        BAYC.safeMint(jf, 5);
+        BAYC.safeMint(jf, 6);
+        BAYC.safeMint(jf, 7);
+        BAYC.safeMint(jf, 8);
+        BAYC.safeMint(jf, 9);
+
+        // SORA
+        SORA.safeMint(gab, 0);
+        SORA.safeMint(gab, 1);
+        SORA.safeMint(gab, 2);
+        SORA.safeMint(gab, 3);
+        SORA.safeMint(gab, 4);
+
+        SORA.safeMint(jf, 5);
+        SORA.safeMint(jf, 6);
+        SORA.safeMint(jf, 7);
+        SORA.safeMint(jf, 8);
+        SORA.safeMint(jf, 9);
+
+        // MAYC
+        MAYC.safeMint(gab, 0);
+        MAYC.safeMint(gab, 1);
+        MAYC.safeMint(gab, 2);
+        MAYC.safeMint(gab, 3);
+        MAYC.safeMint(gab, 4);
+
+        MAYC.safeMint(jf, 5);
+        MAYC.safeMint(jf, 6);
+        MAYC.safeMint(jf, 7);
+        MAYC.safeMint(jf, 8);
+        MAYC.safeMint(jf, 9);
 
         vm.stopBroadcast();
     }

script/DeployEchoBlast.s.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.18;
+
+import "forge-std/Script.sol";
+import "../src/EchoBlast.sol";
+import "../test/mock/YieldMock.sol";
+
+contract DeployEchoBlast is Script {
+    // Exclude from coverage report
+    function test() public {}
+
+    function run() external {
+        vm.createSelectFork(vm.envString("BLAST_SEPOLIA_RPC_URL"));
+        // Deploy mock of the precompile
+        YieldMock yieldMock = new YieldMock();
+        // Set mock bytecode to the expected precompile address
+        vm.etch(0x0000000000000000000000000000000000000100, address(yieldMock).code);
+
+        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
+        vm.startBroadcast(deployerPrivateKey);
+        new EchoBlast({
+            owner: address(0x213bE2f484Ab480db4f18b0Fe4C38e1C25877f09),
+            blastPointsAddress: address(0x2fc95838c71e76ec69ff817983BFf17c710F34E0)
+        });
+
+        vm.stopBroadcast();
+    }
+}

script/TestPacking.s.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.18;
+
+import "forge-std/Script.sol";
+import "../src/Echo.sol";
+
+contract TestPacking is Script {
+    // Exclude from coverage report
+    function test() public {}
+
+    function run() external {
+        OfferItem[] memory offerItems = new OfferItem[](1);
+        offerItems[0] = OfferItem({tokenAddress: 0x7DA16cd402106Adaf39092215DbB54092b80B6E6, tokenId: 2});
+
+        Offer memory offer = Offer({
+            sender: 0x7DA16cd402106Adaf39092215DbB54092b80B6E6,
+            receiver: 0x7DA16cd402106Adaf39092215DbB54092b80B6E6,
+            senderItems: OfferItems({chainId: 1, items: offerItems}),
+            receiverItems: OfferItems({chainId: 1, items: offerItems}),
+            expiration: 1,
+            state: OfferState.OPEN
+        });
+
+        bytes memory offerIdHash = abi.encode(
+            offer.sender,
+            offer.receiver,
+            offer.senderItems.chainId,
+            keccak256(abi.encode(offer.senderItems.items)), // OfferItem[]
+            offer.receiverItems.chainId,
+            keccak256(abi.encode(offer.receiverItems.items)), // OfferItem[]
+            offer.expiration
+        );
+        bytes32 offerId = keccak256(offerIdHash);
+
+        console.logBytes(offerIdHash);
+        console.logBytes32(offerId);
+    }
+}

script/UpdateEchoFees.s.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.18;
+
+import "forge-std/Script.sol";
+import "../src/Echo.sol";
+
+contract UpdateEchoFees is Script {
+    // Exclude from coverage report
+    function test() public {}
+
+    function run() external {
+        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
+        vm.startBroadcast(deployerPrivateKey);
+        Echo echo = Echo(0xB0904D81440EFCA27Ec61948c95f21D7d546F8C3);
+        echo.setFees(0.005 ether);
+        vm.stopBroadcast();
+    }
+}

src/Echo.sol

@@ -15,12 +15,12 @@ contract Echo is ReentrancyGuard, Admin, Banker, Escrow, EchoState {
     event OfferAccepted(bytes32 indexed offerId);
     event OfferCanceled(bytes32 indexed offerId);
     event OfferExecuted(bytes32 indexed offerId);
-    // @dev For future use...
 
-    uint16 private immutable CHAIN_ID;
+    // @dev For future use...
+    uint256 private immutable CHAIN_ID;
 
     constructor(address owner) Admin(owner) {
-        CHAIN_ID = uint16(block.chainid);
+        CHAIN_ID = block.chainid;
     }
 
     /**

src/EchoBlast.sol

@@ -2,8 +2,8 @@
 pragma solidity ^0.8.18;
 
 import "./Echo.sol";
-import "blast/IBlast.sol";
-import "blast/IBlastPoints.sol";
+import "../lib/blast/IBlast.sol";
+import "../lib/blast/IBlastPoints.sol";
 
 contract EchoBlast is Echo {
     IBlast public constant BLAST = IBlast(0x4300000000000000000000000000000000000002);

src/EchoState.sol

@@ -48,7 +48,7 @@ abstract contract EchoState {
      * Same chain offers
      */
     // @dev Internal function to create a same chain offer
-    function _createOffer(Offer calldata offer, uint16 chainId) internal returns (bytes32 offerId) {
+    function _createOffer(Offer calldata offer, uint256 chainId) internal returns (bytes32 offerId) {
         offerId = _generateOfferId(offer);
 
         _validateOffer(offer);

test/mock/YieldMock.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.18;
+
+contract YieldMock {
+    address private constant blastContract = 0x4300000000000000000000000000000000000002;
+
+    mapping(address => uint8) public getConfiguration;
+
+    function configure(address contractAddress, uint8 flags) external returns (uint256) {
+        require(msg.sender == blastContract);
+
+        getConfiguration[contractAddress] = flags;
+        return 0;
+    }
+
+    function claim(address, address, uint256) external pure returns (uint256) {
+        return 0;
+    }
+
+    function getClaimableAmount(address) external pure returns (uint256) {
+        return 0;
+    }
+}