First commit

Author: aviggiano

.github/workflows/ci.yml

@@ -0,0 +1,55 @@
+name: CI
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+  push:
+    branches:
+      - main
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  fmt:
+    strategy:
+      fail-fast: true
+
+    name: Format
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      - name: Setup Foundry
+        uses: foundry-rs/foundry-toolchain@v1
+        with:
+          version: stable
+
+      - name: Format
+        run: |
+          forge fmt --check
+        id: fmt
+
+  test:
+    strategy:
+      fail-fast: true
+
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      - name: Setup Foundry
+        uses: foundry-rs/foundry-toolchain@v1
+        with:
+          version: stable
+
+      - name: Test
+        run: |
+          forge test --ffi -vvv
+        id: test

.github/workflows/test.yml

@@ -1,3 +1,9 @@
 [submodule "lib/forge-std"]
 	path = lib/forge-std
 	url = https://github.com/foundry-rs/forge-std
+[submodule "lib/openzeppelin-contracts"]
+	path = lib/openzeppelin-contracts
+	url = https://github.com/openzeppelin/openzeppelin-contracts
+[submodule "lib/solidity-stringutils"]
+	path = lib/solidity-stringutils
+	url = https://github.com/Arachnid/solidity-stringutils

.gitmodules

@@ -1,66 +1,80 @@
-## Foundry
+## solidity-http
 
-**Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.**
+Solidity HTTP client library for Foundry scripting
 
-Foundry consists of:
+### Installation
 
--   **Forge**: Ethereum testing framework (like Truffle, Hardhat and DappTools).
--   **Cast**: Swiss army knife for interacting with EVM smart contracts, sending transactions and getting chain data.
--   **Anvil**: Local Ethereum node, akin to Ganache, Hardhat Network.
--   **Chisel**: Fast, utilitarian, and verbose solidity REPL.
+```bash
+forge install Recon-Fuzz/solidity-http
+```
 
-## Documentation
+### Usage
 
-https://book.getfoundry.sh/
+### 1. Import the library
 
-## Usage
+```solidity
+import {HTTP} from "solidity-http/HTTP.sol";
+import {HTTPBuilder} from "solidity-http/HTTPBuilder.sol";
+```
 
-### Build
+### 2. Build and send your request
 
-```shell
-$ forge build
-```
+Use builder functions to compose your request with headers, body, and query parameters.
 
-### Test
+```solidity
+contract MyScript is Script {
+    using HTTPBuilder for HTTP.Request;
 
-```shell
-$ forge test
-```
+    HTTP.Request request;
+
+    function run() external {
+        request
+            .withUrl("https://httpbin.org/post")
+            .withMethod(HTTP.Method.POST)
+            .withHeader("Content-Type", "application/json")
+            .withBody('{"foo": "bar"}');
 
-### Format
+        HTTP.Response memory response = HTTP.request(request);
 
-```shell
-$ forge fmt
+        console.log("Status:", response.status);
+        console.log("Data:", response.data);
+    }
+}
 ```
 
-### Gas Snapshots
+### 3. Enable FFI
 
-```shell
-$ forge snapshot
-```
+This library relies on Foundry's [FFI cheatcode](https://book.getfoundry.sh/cheatcodes/ffi.html) to call external processes. Enable it by:
 
-### Anvil
+- Passing the `--ffi` flag to your command:
 
-```shell
-$ anvil
+```bash
+forge test --ffi
 ```
 
-### Deploy
+- Or setting `ffi = true` in your `foundry.toml`:
 
-```shell
-$ forge script script/Counter.s.sol:CounterScript --rpc-url <your_rpc_url> --private-key <your_private_key>
+```toml
+[profile.default]
+ffi = true
 ```
 
-### Cast
+---
 
-```shell
-$ cast <subcommand>
-```
+## Requirements
 
-### Help
+- Foundry with FFI enabled:
+  - Either pass `--ffi` to commands (e.g. `forge test --ffi`)
+  - Or set `ffi = true` in `foundry.toml`
 
-```shell
-$ forge --help
-$ anvil --help
-$ cast --help
+```toml
+[profile.default]
+ffi = true
 ```
+
+- A UNIX-based machine with the following installed:
+  - `bash`, `curl`, `tail`, `sed`, `tr`, `cast`
+
+### Acknowledgements
+
+This library was inspired by [surl](https://github.com/memester-xyz/surl) and [axios](https://github.com/axios/axios)

README.md

@@ -0,0 +1,6 @@
+@openzeppelin=lib/openzeppelin-contracts
+@src=src
+@test=test
+@script=script
+solidity-stringutils=lib/solidity-stringutils
+

lib/openzeppelin-contracts

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {Vm} from "forge-std/Vm.sol";
+import {StringMap} from "@src/StringMap.sol";
+
+library HTTP {
+    using StringMap for StringMap.StringToStringMap;
+
+    Vm constant vm = Vm(address(bytes20(uint160(uint256(keccak256("hevm cheat code"))))));
+
+    enum Method {
+        GET,
+        POST,
+        PUT,
+        DELETE,
+        PATCH
+    }
+
+    struct Request {
+        string url;
+        string body;
+        Method method;
+        StringMap.StringToStringMap headers;
+        StringMap.StringToStringMap query;
+    }
+
+    struct Response {
+        uint256 status;
+        string data;
+    }
+
+    function request(Request storage req) internal returns (Response memory res) {
+        string memory scriptStart = 'response=$(curl -s -w "\\n%{http_code}" ';
+        string memory scriptEnd =
+            '); status=$(tail -n1 <<< "$response"); data=$(sed "$ d" <<< "$response");data=$(echo "$data" | tr -d "\\n"); cast abi-encode "response(uint256,string)" "$status" "$data";';
+
+        string memory curlParams = "";
+
+        for (uint256 i = 0; i < req.headers.length(); i++) {
+            (string memory key, string memory value) = req.headers.at(i);
+            curlParams = string.concat(curlParams, '-H "', key, ": ", value, '" ');
+        }
+
+        curlParams = string.concat(curlParams, " -X ", toString(req.method), " ");
+
+        if (bytes(req.body).length > 0) {
+            curlParams = string.concat(curlParams, "-d '", req.body, "' ");
+        }
+
+        string memory quotedURL = string.concat('"', req.url, '"');
+
+        string[] memory inputs = new string[](3);
+        inputs[0] = "bash";
+        inputs[1] = "-c";
+        inputs[2] = string.concat(scriptStart, curlParams, quotedURL, scriptEnd, "");
+        bytes memory output = vm.ffi(inputs);
+
+        (res.status, res.data) = abi.decode(output, (uint256, string));
+    }
+
+    function toString(Method method) internal pure returns (string memory) {
+        if (method == Method.GET) {
+            return "GET";
+        } else if (method == Method.POST) {
+            return "POST";
+        } else if (method == Method.PUT) {
+            return "PUT";
+        } else if (method == Method.DELETE) {
+            return "DELETE";
+        } else if (method == Method.PATCH) {
+            return "PATCH";
+        } else {
+            revert();
+        }
+    }
+}