Ethereum Improvement Proposals

https://eips.ethereum.org/
Admin
Ethereum Improvement Proposals (EIPs) describe standards for the Ethereum platform, including core...
Tokens:4,396,678
Snippets:25,536
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install Go Snappy library

Source: https://eips.ethereum.org/EIPS/eip-706

Install the Go Snappy library using go get. This is a prerequisite for running the Go verification snippet.

```bash
$ go get https://github.com/golang/snappy

```

--------------------------------

### Module onInstall example with moduleTypeId

Source: https://eips.ethereum.org/EIPS/eip-7579

Example of a module's onInstall function decoding moduleTypeId from data. Shows how a multi-type module can handle installation for various types.

```solidity
// Module.sol
function onInstall(bytes calldata data) external {
    // ...
    (uint256 moduleTypeId, bytes memory otherData) = abi.decode(data, (uint256, bytes));
    // ...
}
```

--------------------------------

### Install dependencies and run tests

Source: https://eips.ethereum.org/assets/eip-6982

Commands to install pnpm globally, install project dependencies, and run the test suite.

```bash
npm i -g pnpm
pnpm i
pnpm test

```

--------------------------------

### Install NTT with make install

Source: https://eips.ethereum.org/assets/eip-7885/pythonref

Installs the NTT implementation. Requires the file ntt_constants.py, generated using python generate_constants.py.

```makefile
make install

```

--------------------------------

### Example Configuration for ERC-721 Project (JSON)

Source: https://eips.ethereum.org/EIPS/eip-7876

Example configuration for an ERC-721 project deployed to Ethereum Mainnet and Sepolia. It illustrates multi-network setup with network details, RPCs, explorers, and contracts. Recommended to use two-space indentation for readability.

```json
{
  "version": "0.0.1",
  "timestamp": "2025-01-01T12:22:46.471Z",
  "summary": "NFT Artwork",
  "description": "Artwork published by independent artist. Carefully crafted with style in one of the creative studios of the world.",
  "abiRoot": "https://nft-artwork.example.com/developer/abi",
  "networks": {
    "1": {
      "name": "Ethereum Mainnet",
      "testnet": false,
      "nativeCurrency": {
        "name": "Ether",
        "symbol": "ETH",
        "decimals": 18
      },
      "rpcs": {
        "main": {
          "url": "https://eth-rpc.example.com"
        },
        "backup": {
          "url": "https://eth-rpc.backup.example.com"
        }
      },
      "relations": {
        "mainnetChainId": null,
        "parentChainId": null
      },
      "explorers": {
        "megascan": {
          "root": "https://example.org",
          "block": "/block/:block",
          "address": "/address/:address",
          "tx": "/tx/:tx",
          "nft": "/nft/:address/:token"
        },
        "marketplace": {
          "root": "https://nft.marketplace/networks/eth",
          "block": null,
          "address": "/:address",
          "tx": null,
          "nft": "/:address/:token"
        }
      },
      "contracts": {
        "Registry": {
          "address": "0x57928ff7b0BBc3Ee4D84481e320DdB8B941f986A",
          "blockCreated": 1234567,
          "abiUrl": "./Registry.sol/Registry.json"
        },
        "OwnerWallet": {
          "address": "0xC12237E57B088e9191BD8054Df4f5B772646a4B6",
          "blockCreated": 1
        }
      }
    },
    "11155111": {
      "name": "Sepolia",
      "testnet": true,
      "nativeCurrency": {
        "name": "Sepolia Ether",
        "symbol": "ETH",
        "decimals": 18
      },
      "rpcs": {
        "main": {
          "url": "https://sepolia-rpc.example.com"
        },
        "backup": {
          "url": "https://sepolia-rpc.backup.example.com"
        }
      },
      "relations": {
        "mainnetChainId": 1,
        "parentChainId": null
      },
      "explorers": {
        "megascan": {
          "root": "https://sepolia.example.org",
          "block": "/block/:block",
          "address": "/address/:address",
          "tx": "/tx/:tx",
          "nft": "/nft/:address/:token"
        },
        "marketplace": {
          "root": "https://testnets.nft.marketplace/networks/sepolia",
          "block": null,
          "address": "/:address",
          "tx": null,
          "nft": "/:address/:token"
        }
      },
      "contracts": {
        "Registry": {
          "address": "0xE13471e6E5d11205AF290261f42108f89dCae72E",
          "blockCreated": 183882,
          "abiUrl": "./Registry.sol/Registry.json" 
        },
        "OwnerWallet": {
          "address": "0xC12237E57B088e9191BD8054Df4f5B772646a4B6",
          "blockCreated": 1
        }
      }
    }
  }
}
```

--------------------------------

### Installation and Execution Commands

Source: https://eips.ethereum.org/EIPS/eip-7908

Commands to install required Python packages and run the script.

```bash
pip install bip32utils eth_account

python stms.py
```

--------------------------------

### Install package with ethpm CLI

Source: https://eips.ethereum.org/EIPS/eip-1319

Command-line example showing how to install a package from a registry using the ethpm CLI. The package is referenced by ENS name 'packages.zeppelin.eth/Ownership'.

```bash
$ ethpm install packages.zeppelin.eth/Ownership

```

--------------------------------

### GET request example

Source: https://eips.ethereum.org/EIPS/eip-3668

Curl command for a GET request to a gateway URL, with successful and error HTTP responses.

```bash
# Client returned a URL template `https://example.com/gateway/{sender}/{data}.json`
# Request
curl -D - https://example.com/gateway/0x226159d592E2b063810a10Ebf6dcbADA94Ed68b8/0xd5fa2b00.json

# Successful result
    HTTP/2 200
    content-type: application/json; charset=UTF-8
    ...
    
    {"data": "0xdeadbeefdecafbad"}

# Error result
    HTTP/2 404
    content-type: application/json; charset=UTF-8
    ...

    {"message": "Gateway address not supported."}
}
```

--------------------------------

### wallet_prepareCalls Example with Response

Source: https://eips.ethereum.org/EIPS/eip-7836

Example of calling wallet_prepareCalls using a provider request, including the expected response object. The example uses a p256 key with prehash set to false and includes a paymasterService capability.

```javascript
const response = await provider.request({
  method: "wallet_prepareCalls",
  params: [
    {
      calls: [
        {
          to: "0xcafebabecafebabecafebabecafebabecafebabe",
          data: "0xdeadbeef",
        },
      ],
      capabilities: {
        paymasterService: {
          url: "https://...",
        },
      },
      chainId: "0x1",
      key: {
        prehash: false,
        publicKey:
          "0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
        type: "p256",
      },
      version: "1",
    },
  ],
});
/**
 * {
 *   capabilities: {
 *     paymasterService: {
 *       url: 'https://...'
 *     }
 *   },
 *   chainId: '0x1',
 *   context: { ... },
 *   digest: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
 *   key: {
 *     prehash: false,
 *     publicKey: '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef',
 *     type: 'p256',
 *   },
 *   version: '1',
 * }
 */
```

--------------------------------

### keyDerivation configuration example

Source: https://eips.ethereum.org/EIPS/eip-8086

Example of the keyDerivation configuration specifying the method and address format.

```json
{
  "method": "EIP-712-Signature",
  "addressFormat": "PV1"
}
```

--------------------------------

### installExecution

Source: https://eips.ethereum.org/EIPS/eip-6900

Installs a module to the modular account, using the provided manifest and optional install data.

```APIDOC
## installExecution

### Description
Install a module to the modular account.

### Function Signature
`function installExecution(address module, ExecutionManifest calldata manifest, bytes calldata installData) external`

### Parameters
- **module** (address) - Required - The module to install.
- **manifest** (ExecutionManifest) - Required - The manifest describing functions to install.
- **installData** (bytes) - Required - Optional data to be used by the account to handle the initial execution setup. Data encoding is implementation-specific.

```

--------------------------------

### wallet_connect Example

Source: https://eips.ethereum.org/EIPS/eip-7846

Example of calling wallet_connect with a signInWithEthereum capability. The response includes the account address and granted capabilities.

```javascript
const response = await provider.request({
  method: 'wallet_connect',
  params: [{
    version: '1',
    capabilities: {
      signInWithEthereum: {
        nonce: '12345678',
        chainId: '0x1'
      }
    }
  }]
})
/**
 * {
 *   accounts: [
 *     {
 *       address: '0x...',
 *       capabilities: {
 *         signInWithEthereum: {
 *           message: 'app.com wants you to sign in with your Ethereum account:\n0x...',
 *           signature: '0x...'
 *         }
 *       }
 *     }
 *   ]
 * }
 */
```

--------------------------------

### Example response for wallet_getSupportedExecutionPermissions

Source: https://eips.ethereum.org/EIPS/eip-7715

Example JSON object showing supported permission types with chainIds and ruleTypes. Note the typo 'rulesTypes' in the example.

```json
{
  "native-token-allowance": {
    "chainIds": ["0x123", "0x345"],
    "rulesTypes": ["expiry"]
  },
  "erc20-token-allowance": {
    "chainIds": ["0x123"],
    "rulesTypes": []
  },
  "erc721-token-allowance": {
    "chainIds": ["0x123"],
    "rulesTypes": ["expiry"]
  }
}

```

--------------------------------

### Install Dependencies with yarn install

Source: https://eips.ethereum.org/assets/eip-7858

Run this command to install the project dependencies required for the ERC-7858 reference implementation.

```bash
yarn install

```

--------------------------------

### hashFunction configuration example

Source: https://eips.ethereum.org/EIPS/eip-8086

Example of the hashFunction configuration specifying the hash function name and parameters.

```json
{
  "name": "Poseidon",
  "parameters": {
    "t": 3,
    "nRoundsF": 8,
    "nRoundsP": 57
  }
}
```

--------------------------------

### Install dependencies with npm install

Source: https://eips.ethereum.org/assets/eip-4675

Installs the project dependencies using npm.

```bash
npm install

```

--------------------------------

### Connect event listener example

Source: https://eips.ethereum.org/EIPS/eip-2786

Example of attaching a listener to the 'connect' event, logging the chainId when the provider connects.

```javascript
// connect
provider.on('connect', ({ chainId }) => {
  console.log(`Provider connected to: ${chainId}`);
});
```

--------------------------------

### Install Python Snappy library

Source: https://eips.ethereum.org/EIPS/eip-706

Install the Python Snappy library using pip. This is a prerequisite for running the Python verification snippet.

```bash
$ pip install python-snappy

```

--------------------------------

### wallet_getCapabilities Example Response

Source: https://eips.ethereum.org/EIPS/eip-7677

Example JSON response for a `wallet_getCapabilities` call showing the `paymasterService` capability supported on two chains.

```json
{
  "0x2105": {
    "paymasterService": {
      "supported": true
    }
  },
  "0x14A34": {
    "paymasterService": {
      "supported": true
    }
  }
}
```

--------------------------------

### Example response for wallet_getGrantedExecutionPermissions

Source: https://eips.ethereum.org/EIPS/eip-7715

Example array of granted permissions, each containing chainId, from, to, permission details, context, dependencies, and delegationManager.

```json
[
  {
    chainId: "0x01",
    from: "0x...",
    to: "0x016562aA41A8697720ce0943F003141f5dEAe006",
    permission: {
      type: "native-token-allowance",
      isAdjustmentAllowed: true,
      data: {
        allowance: "0x1DCD65000000",
      },
    },
    context: "0x0x016562aA41A8697720ce0943F003141f5dEAe0060000771577157715",
    dependencies: [
      {
        factory: "0x...",
        factoryData: "0x...",
      },
    ],
    delegationManager: "0x...",
  },
];

```

--------------------------------

### wallet_getSupportedExecutionPermissions request example

Source: https://eips.ethereum.org/EIPS/eip-7715

Example of calling the wallet_getSupportedExecutionPermissions method via window.ethereum.request. Returns a Promise of GetSupportedExecutionPermissionsResult.

```javascript
window.ethereum.request({
  "method": "wallet_getSupportedExecutionPermissions",
  "params": []
}): Promise<GetSupportedExecutionPermissionsResult>

```

--------------------------------

### Example 2: URI with function call

Source: https://eips.ethereum.org/EIPS/eip-67

Same transaction as Example 1 but using a readable function call that the client converts to bytecode.

```text
 ethereum:0x89205A3A3b2A69De6Dbf7f01ED13B2108B2c43e7?gas=100000&function=transfer(address 0xdeadbeef, uint 5)

```

--------------------------------

### Recap-uri for the example

Source: https://eips.ethereum.org/EIPS/eip-5573

This is the expected recap-uri for the ReCap Capability Object example, encoding the same authorization information in a compact URI format.

```text
urn:recap:eyJhdHQiOnsiaHR0cHM6Ly9leGFtcGxlLmNvbS9waWN0dXJlcy8iOnsiY3J1ZC9kZWxldGUiOlt7fV0sImNydWQvdXBkYXRlIjpbe31dLCJvdGhlci9hY3Rpb24iOlt7fV19LCJtYWlsdG86dXNlcm5hbWVAZXhhbXBsZS5jb20iOnsibXNnL3JlY2VpdmUiOlt7Im1heF9jb3VudCI6NSwidGVtcGxhdGVzIjpbIm5ld3NsZXR0ZXIiLCJtYXJrZXRpbmciXX1dLCJtc2cvc2VuZCI6W3sidG8iOiJzb21lb25lQGVtYWlsLmNvbSJ9LHsidG8iOiJqb2VAZW1haWwuY29tIn1dfX0sInByZiI6WyJ6ZGo3V2o2Rk5TNHJVVWJzaUp2amp4Y3NOcVpkRENTaVlSOHNLUVhmb1BmcFNadUF3Il19

```

--------------------------------

### signInWithEthereum Example

Source: https://eips.ethereum.org/EIPS/eip-7846

Example of requesting signInWithEthereum capability with full parameters. The response includes the SIWE message and signature.

```javascript
const result = await provider.request({
  method: 'wallet_connect',
  params: [{
    version: '1',
    capabilities: {
      signInWithEthereum: {
        nonce: '12345678',
        chainId: '0x1',
        version: '1',
        domain: 'app.com',
        uri: 'https://app.com/connect',
        issuedAt: '2024-12-35T04:20:00Z',
        expirationTime: '2024-12-35T06:09:00Z'
      }
    }
  }]
})
/**
 * {
 *   accounts: [
 *     {
 *       address: '0x...',
 *       capabilities: {
 *         signInWithEthereum: {
 *           message: 'app.com wants you to sign in with your Ethereum account:\n0x...',
 *           signature: '0x...'
 *         }
 *       }
 *     }
 *   ]
 * }
 */
```

--------------------------------

### Native Asset Example

Source: https://eips.ethereum.org/EIPS/eip-7811

Example JSON object for a native asset, showing the required fields: address, balance, and type.

```json
{
  "address": "native",
  "balance": "0xcaaea35047fe5702",
  "type": "native"
}
```

--------------------------------

### setup

Source: https://eips.ethereum.org/EIPS/eip-2266

Sets up the swap contract with both parties, tokens, and amounts.

```APIDOC
## setup

### Description
Sets up the swap contract, including the both parties involved, the tokens to exchanged, and so on.

### Function Signature
function setup(bytes32 secretHash, address payable initiator, address tokenA, address tokenB, uint256 initiatorAssetAmount, address payable participant, uint256 participantAssetAmount, uint256 premiumAmount) public payable

### Parameters
- **secretHash** (bytes32) - Required - The hash of the secret used for the swap.
- **initiator** (address payable) - Required - The address of the initiator.
- **tokenA** (address) - Required - The token address for the initiator's asset.
- **tokenB** (address) - Required - The token address for the participant's asset.
- **initiatorAssetAmount** (uint256) - Required - The amount of tokenA the initiator wants to sell.
- **participant** (address payable) - Required - The address of the participant.
- **participantAssetAmount** (uint256) - Required - The amount of tokenB the participant wants to sell.
- **premiumAmount** (uint256) - Required - The amount of premium the initiator pays.

### Payable
This function is payable.

```

--------------------------------

### Example initialization using eth_requestAccounts

Source: https://eips.ethereum.org/EIPS/eip-1102

Example code that requests account access using ethereum.send('eth_requestAccounts'), then uses the accounts to send a transaction, with error handling for user denial.

```javascript
try {
    // Request account access if needed
    const accounts = await ethereum.send('eth_requestAccounts');
    // Accounts now exposed, use them
    ethereum.send('eth_sendTransaction', { from: accounts[0], /* ... */ })
} catch (error) {
    // User denied account access
}

```

--------------------------------

### Install liboqs and build op-geth

Source: https://eips.ethereum.org/assets/eip-7885/op-geth/cgo

Install liboqs with NTT CGO bindings, set environment paths for macOS (DYLD_LIBRARY_PATH) or Linux (LD_LIBRARY_PATH), and build op-geth with 'make geth'.

```shell
# Clone and install dependencies
git clone -b feature/ntt-cgo-bindings https://github.com/yhl125/liboqs.git
sudo apt install astyle cmake gcc ninja-build libssl-dev python3-pytest python3-pytest-xdist unzip xsltproc doxygen graphviz python3-yaml valgrind pkg-config

# Build liboqs and Go bindings
cd liboqs/bindings/go
make all
```

```shell
# Set paths (adjust to your installation directory)
export PKG_CONFIG_PATH=/path/to/liboqs/bindings/go/.config:$PKG_CONFIG_PATH
export DYLD_LIBRARY_PATH=/path/to/liboqs/build/lib:$DYLD_LIBRARY_PATH  # macOS
export LD_LIBRARY_PATH=/path/to/liboqs/build/lib:$LD_LIBRARY_PATH      # Linux
```

```shell
make geth
```

--------------------------------

### getLostAccountRecoveryTimeInMinutes(address account)

Source: https://eips.ethereum.org/EIPS/eip-1080

Get the time account has to wait before a lost account dispute can start.

```APIDOC
## getLostAccountRecoveryTimeInMinutes(address account)

### Description
Get the time account has to wait before a lost account dispute can start.

### Function Signature
```solidity
function getLostAccountRecoveryTimeInMinutes(address account) view returns (uint256 minutes)
```

### Parameters
- **account** (address) - Required - The account to query.

### Returns
- **minutes** (uint256) - The time in minutes the account has to wait before a lost account dispute can start.
```

--------------------------------

### Initial Write Example

Source: https://eips.ethereum.org/EIPS/eip-7827

Shows writing a new key-value pair with replace=false, resulting in JSON output and version history.

```solidity
write(["name"], ["Alice"], false);
```

```json
{ "name": "Alice" }
```

```json
["Alice"]
```

--------------------------------

### Account.sol - contract Account inheriting Adapter

Source: https://eips.ethereum.org/EIPS/eip-7484

Example contract that inherits Adapter and uses the checkModule function before installing or executing a module. Not binding, but complies with the Specification.

```solidity
contract Account is Adapter {
    ...

    // installs a module
    function installModule(
        uint256 moduleTypeId,
        address module,
        bytes calldata initData
    )
        external
        payable
    {
        checkModule(module);
        ...
    }

    // executes a module
    function executeFromExecutor(
        ModeCode mode,
        bytes calldata executionCalldata
    )
        external
        payable
        returns (bytes[] memory returnData)
    {
        checkModule(module);
        ...
    }

    ...
}

```

--------------------------------

### Build and run commands

Source: https://eips.ethereum.org/assets/eip-7979/riscv

Commands to set up the toolchain and run the harness, with optional phases.

```shell
sh setup.sh
```

```shell
python3 harness.py
```

--------------------------------

### Package Names and Release Versions

Source: https://eips.ethereum.org/EIPS/eip-1319

Example of package name and version string format used in the registry.

```text
"simple-token" # package name
"1.0.1"        # version string

```

--------------------------------

### Upgrader contract interface in Solidity

Source: https://eips.ethereum.org/EIPS/eip-1504

Defines the Upgrader contract with status enum, modifiers, and functions for starting proposals, getting resolutions, and self-destruction. Includes checks for expiration and preparation.

```solidity
/// Handler upgrader
contract Upgrader {
    // Data contract
    DataContract public data;
    // Original Handler contract
    IHandler public originalHandler;
    // New Handler contract
    address public newHandlerAddr;

    /** Marker */
    enum UpgraderStatus {
        Preparing,
        Voting,
        Success,
        Expired,
        End
    }
    UpgraderStatus public status;

    /// Check if the proposal is expired.
    /// If so, contract would be marked as expired.
    /// exception   PreparingUpgraderException  proposal has not been started.
    /// exception   ReupgradingException    upgrading has been done.
    /// exception   ExpirationException proposal is expired.
    modifier notExpired {
        require(status != UpgraderStatus.Preparing, "Invalid proposal!");
        require(status != UpgraderStatus.Success, "Upgrading has been done!");
        require(status != UpgraderStatus.Expired, "Proposal is expired!");
        if (data.canBeUpgraded(address(originalHandler)) != DataContract.UpgradingStatus.InProgress) {
            status = UpgraderStatus.Expired;
            require(false, "Proposal is expired!");
        }
        _;
    }

    /// Start voting.
    /// Upgrader must do upgrading check, namely checking if Data contract and 2 Handler contracts are ok.
    /// exception   RestartingException proposal has been already started.
    /// exception   PermissionException msg.sender is not the owner.
    /// exception   UpgraderConflictException   another upgrader is working.
    /// exception   NoPreparationException  original or new Handler contract is not prepared.
    function startProposal () external;

    /// Anyone can try to get resolution.
    /// If voters get consensus, upgrade the Handler contract.
    /// If expired, self-destruct.
    /// Otherwise, do nothing.
    /// exception   PreparingUpgraderException  proposal has not been started.
    /// exception   ExpirationException proposal is expired.
    /// @return     status of proposal.
    function getResolution() external returns(UpgraderStatus);

    /// Destruct itself.
    /// exception   PermissionException msg.sender is not the owner.
    function done() external;

    /** Other voting mechanism related variables and functions */
}
```

--------------------------------

### Install dependencies, compile, and test with Truffle

Source: https://eips.ethereum.org/assets/eip-6809

Run these commands in order to set up and verify the EIP-6809 implementation. Requires Node.js and Truffle installed.

```bash
npm i
truffle compile
truffle test

```

--------------------------------

### IPFS contenthash example

Source: https://eips.ethereum.org/EIPS/eip-1577

Example for IPFS content: includes the input data fields (0xe3, CID version 1, dag-pb, sha2-256, 32-byte hash), the binary encoding in hex starting with 0xe30101701220..., and the textual representation with the ipfs:// prefix. The binary and text formats are directly derived from the input data.

```text
storage system: IPFS (0xe3)
CID version: 1 (0x01)
content type: dag-pb (0x70)
hash function: sha2-256 (0x12)
hash length: 32 bytes (0x20)
hash: 29f2d17be6139079dc48696d1f582a8530eb9805b561eda517e22a892c7e3f1f

```

```text
0xe3010170122029f2d17be6139079dc48696d1f582a8530eb9805b561eda517e22a892c7e3f1f

```

```text
ipfs://QmRAQB6YaCyidP37UdDnjFY5vQuiBrcqdyoW1CuDgwxkD4

```

--------------------------------

### eth_getTransactionCount Request and Response

Source: https://eips.ethereum.org/EIPS/eip-1474

Example curl request to get the number of transactions sent from an address, with the response showing the count as a hex quantity. The request uses the 'latest' block parameter.

```bash
# Request
curl -X POST --data '{
    "id": 1337,
    "jsonrpc": "2.0",
    "method": "eth_getTransactionCount",
    "params": ["0xc94770007dda54cF92009BFF0dE90c06F603a09f", "latest"]
}' <url>

# Response
{
    "id": 1337,
    "jsonrpc": "2.0",
    "result": "0x1"
}
```

--------------------------------

### Multi-option pricing example (USDC on Base or Ethereum)

Source: https://eips.ethereum.org/EIPS/eip-8257

Example JSON manifest with two pricing entries, each specifying a 0.02 USDC payment via the x402 protocol on Base and Ethereum respectively.

```json
{
  "pricing": [
    {
      "amount": "20000",
      "asset": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
      "recipient": "eip155:8453:0xabcdef0123456789abcdef0123456789abcdef01",
      "protocol": "x402"
    },
    {
      "amount": "20000",
      "asset": "eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
      "recipient": "eip155:1:0xabcdef0123456789abcdef0123456789abcdef01",
      "protocol": "x402"
    }
  ]
}

```

--------------------------------

### startAuctions(bytes32[] _hashes)

Source: https://eips.ethereum.org/EIPS/eip-162

Starts multiple auctions on an array of hashes. This enables opening dummy auctions to increase cost for attackers.

```APIDOC
## startAuctions(bytes32[] _hashes)

### Description
Starts multiple auctions on an array of hashes. This enables opening dummy auctions to increase cost for attackers.

### Method
Function call

### Parameters
- **_hashes** (bytes32[]) - Required - An array of hashes to start auctions for.
```

--------------------------------

### Resolve a name with ENS: get resolver then addr

Source: https://eips.ethereum.org/EIPS/eip-137

Two steps to resolve a name: first obtain the resolver for a hashed name, then ask the resolver for the address. In this example the name is 'beercoin.eth'.

```javascript
var node = namehash("beercoin.eth");
var resolver = ens.resolver(node);

```

```javascript
var address = resolver.addr(node);

```

--------------------------------

### createFromCalldata - MetaProxy construction from calldata

Source: https://eips.ethereum.org/EIPS/eip-3448

Example Solidity function that constructs a MetaProxy by using the calldata after the 4th byte as metadata. It calls MetaProxyFactory._metaProxyFromCalldata(), checks the proxy address, and performs optional one-time setup.

```solidity
/// @notice MetaProxy construction via calldata.
function createFromCalldata (
  address a,
  uint256 b,
  uint256[] calldata c
) external payable returns (address proxy) {
  // creates a new proxy where the metadata is everything after the 4th byte from calldata.
  proxy = MetaProxyFactory._metaProxyFromCalldata(address(this));
  require(proxy != address(0));
  // optional one-time setup, a constructor() substitute
  MyContract(proxy).init{ value: msg.value }();
}

```

--------------------------------

### eth_getTransactionReceipt Request and Response

Source: https://eips.ethereum.org/EIPS/eip-1474

Example curl request to get the receipt of a transaction by hash, with the response containing the full receipt object including block hash, gas used, and status. Note that receipts are unavailable for pending transactions.

```bash
# Request
curl -X POST --data '{
    "id": 1337,
    "jsonrpc": "2.0",
    "method": "eth_getTransactionReceipt",
    "params": ["0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"]
}' <url>

# Response
{
    "id": 1337,
    "jsonrpc": "2.0",
    "result": {
        "blockHash": '0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b',
        "blockNumber": '0xb',
        "contractAddress": '0xb60e8dd61c5d32be8058bb8eb970870f07233155',
        "cumulativeGasUsed": '0x33bc',
        "gasUsed": '0x4dc',
        "logs": [],
        "logsBloom": "0x00...0",
        "status": "0x1",
        "transactionHash": '0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238',
        "transactionIndex":  '0x1'
    }
}
```

--------------------------------

### createFromBytes - MetaProxy construction from abi.encode bytes

Source: https://eips.ethereum.org/EIPS/eip-3448

Example Solidity function that constructs a MetaProxy using a bytes argument from abi.encode(). It calls MetaProxyFactory._metaProxyFromBytes(), requires a non-zero proxy address, and optionally performs one-time setup via MyContract(proxy).init().

```solidity
/// @notice MetaProxy construction via abi encoded bytes.
function createFromBytes (
  address a,
  uint256 b,
  uint256[] calldata c
) external payable returns (address proxy) {
  // creates a new proxy where the metadata is the result of abi.encode()
  proxy = MetaProxyFactory._metaProxyFromBytes(address(this), abi.encode(a, b, c));
  require(proxy != address(0));
  // optional one-time setup, a constructor() substitute
  MyContract(proxy).init{ value: msg.value }();
}

```

--------------------------------

### ERC-7578 Reference Implementation (Solidity)

Source: https://eips.ethereum.org/EIPS/eip-7578

An example ERC-721 contract implementing the ERC-7578 standard. It includes functions to get, set, and remove token properties, and overrides the _update function to enforce property initialization before minting and to remove properties on burn. The contract uses OpenZeppelin's ERC721 and defines a custom error for uninitialized properties.

```solidity
pragma solidity ^0.8.21;

import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import { IERC7578, Properties, Amount } from "./interfaces/IERC7578.sol";

/**
 * @title ERC7578
 * @author DESAT
 * @notice Implementation of the ERC-7578: Physical Asset Redemption standard
 **/
contract ERC7578 is ERC721, IERC7578 {
    /**
     * @notice Thrown when the properties of a token are not initialized
     */
    error PropertiesUninitialized();

    /**
     * @notice Retrieves the properties of the `tokenId` token
     */
    mapping(uint256 tokenId => Properties) private _properties;

    /**
     * @notice Initializes the name and symbol of the ERC-721 collection
     */
    constructor(string memory _name, string memory _symbol) ERC721(_name, _symbol) {}

    /**
     * @inheritdoc IERC7578
     */
    function getPropertiesOf(uint256 tokenId) public view override returns (Properties memory properties) {
        properties = _properties[tokenId];
    }

    /**
     * @notice Initializes the ERC-7578 properties of the `tokenId` token
     *
     * WARNING: This method should only be called within a function that has appropriate access control
     * It is recommended to restrict access to trusted Externally Owned Accounts (EOAs),
     * authorized contracts, or implement a Role-Based Access Control (RBAC) mechanism
     * Failure to properly secure this method could lead to unauthorized modification of token properties
     *
     * Emits a {PropertiesSet} event
     */
    function _setPropertiesOf(uint256 tokenId, Properties calldata properties) internal {
        _properties[tokenId] = Properties({
            tokenIssuer: properties.tokenIssuer,
            assetHolder: properties.assetHolder,
            storageLocation: properties.storageLocation,
            terms: properties.terms,
            jurisdiction: properties.jurisdiction,
            declaredValue: Amount({
                currency: properties.declaredValue.currency,
                value: properties.declaredValue.value
            })
        });

        emit PropertiesSet(tokenId, _properties[tokenId]);
    }

    /**
     * @notice Removes the properties of the `tokenId` token
     * @param tokenId The unique identifier of the token whose properties are to be removed
     *
     * Emits a {PropertiesRemoved} event
     */
    function _removePropertiesOf(uint256 tokenId) internal {
        delete _properties[tokenId];
        emit PropertiesRemoved(tokenId);
    }

    /**
     * @notice Override of the {_update} function to remove the properties of the `tokenId` token or
     * to check if they are set before minting
     * @param tokenId The unique identifier of the token being minted or burned
     */
    function _update(address to, uint256 tokenId, address auth) internal virtual override returns (address) {
        address from = _ownerOf(tokenId);
        if (to == address(0)) {
            _removePropertiesOf(tokenId);
        } else if (from == address(0)) {
            if (bytes(_properties[tokenId].tokenIssuer).length == 0) revert PropertiesUninitialized();
        }

        return super._update(to, tokenId, auth);
    }
}

```

--------------------------------

### Start Ganache-CLI test network

Source: https://eips.ethereum.org/EIPS/eip-2615

Run this command to create a test network with Ganache-CLI before running the tests. It sets 15 accounts, a high gas limit, and an initial balance of 1,000,000,000 ether.

```bash
ganache-cli -a 15  --gasLimit=0x1fffffffffffff -e 1000000000

```

--------------------------------

### Sample Response

Source: https://eips.ethereum.org/EIPS/eip-7555

Example of the callback URL that the provider redirects to, containing the smart account address.

```text
http://myapp.com/callback/?smart_account_address=0xb...c
```

--------------------------------

### Example 1: URI with bytecode

Source: https://eips.ethereum.org/EIPS/eip-67

Example URI that sends 5 unicorns to address 0xdeadbeef, using the transfer function's bytecode.

```text
 ethereum:0x89205A3A3b2A69De6Dbf7f01ED13B2108B2c43e7?gas=100000&data=0xa9059cbb00000000000000000000000000000000000000000000000000000000deadbeef0000000000000000000000000000000000000000000000000000000000000005

```

--------------------------------

### Example of sending prepared calls with signature

Source: https://eips.ethereum.org/EIPS/eip-7836

JavaScript example that first calls wallet_prepareCalls to obtain a digest and request, then signs the digest with p256.sign, and finally sends the prepared calls with wallet_sendPreparedCalls. The response is shown as a comment.

```javascript
const { digest, ...request } = await provider.request({
  method: "wallet_prepareCalls",
  params: [
    {
      calls: [
        {
          to: "0xcafebabecafebabecafebabecafebabecafebabe",
          data: "0xdeadbeef",
        },
      ],
      capabilities: {
        paymasterService: {
          url: "https://...",
        },
      },
      chainId: "0x1",
      key: {
        prehash: false,
        publicKey:
          "0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
        type: "p256",
      },
      version: "1",
    },
  ],
});

const signature = p256.sign(digest, privateKey);

const response = await provider.request({
  method: "wallet_sendPreparedCalls",
  params: [
    {
      ...request,
      signature,
    },
  ],
});
/**
 * [
 *   {
 *     id: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
 *   }
 * ]
 */
```

--------------------------------

### Build and test with Foundry

Source: https://eips.ethereum.org/assets/eip-8226

Run the build and test commands for the RAMS reference implementation. Requires Foundry to be installed.

```bash
forge build
forge test

```

--------------------------------

### Use case 1: Split code to get around 3m gas barrier

Source: https://eips.ethereum.org/EIPS/eip-7

This Serpent-like pseudocode demonstrates using DELEGATECALL to split contract code into multiple addresses to bypass the 3m gas limit. It copies calldata, checks the first word to decide which address to delegate to, and returns the result. The example uses ~delegate_call with msg.gas - 10000 and a 10000-byte output buffer.

```serpent
~calldatacopy(0, 0, ~calldatasize())
if ~calldataload(0) < 2**253:
    ~delegate_call(msg.gas - 10000, $ADDR1, 0, ~calldatasize(), ~calldatasize(), 10000)
    ~return(~calldatasize(), 10000)
elif ~calldataload(0) < 2**253 * 2:
    ~delegate_call(msg.gas - 10000, $ADDR2, 0, ~calldatasize(), ~calldatasize(), 10000)
    ~return(~calldatasize(), 10000)
...
```

--------------------------------

### Cross-chain function call with RemoteExecuter, Caller, and Foo contracts

Source: https://eips.ethereum.org/EIPS/eip-7841

This example shows a complete cross-chain function call setup. The RemoteExecuter contract is deployed on both chains and handles sending and receiving messages via the Mailbox. The Caller contract on chain A initiates the call, and the Foo contract on chain B executes the function. Note that gas on the destination chain is paid by the caller of RemoteExecuter.execute.

```solidity
/// Contract deployed on both chains A and B
/// This contract takes care of receiving remote calls from the source chain 
///     and of the execution on the destination chain
contract RemoteExecuter {
    /// @notice points to the chain Mailbox
    Mailbox public mailbox;
    /// @notice maps chainId to the canonical RemoteExecuter address
    /// @dev We assume the contract RemoteExecuter is deployed on both (or 
    ///     more) chains, and this map allows to know the address of the 
    ///     contract on the other chain(s).
    mapping(uint32 => address) public remoteExecuterAddress;
    // Track which messages have already been processed
    mapping(bytes32 => bool) private executedMessages;

    /// @notice Prepare the execution function on a another chain
    /// @dev This function sends a message to the destination chain with the 
    ///     parameters of the call
    function remoteCall(
        uint32 destChainId,
        address remoteContractAddress,
        bytes callParams
    ) public {
        Mailbox.Metadata memory metadata = Mailbox.Metadata(
            mailbox.chain_id(),
            destChainId,
            bytes32(address(this)),
            bytes32(remoteExecuterAddress[destChainId]),
            mailbox.randSessionId(),
            0
        );
        mailbox.send(metadata, callParams);
    }

    /// @notice Call a contract function locally based on some message that was 
    ///     sent from another chain
    /// @param srcChainId Identifier of the source chain where the call was 
    ///     initiated
    /// @param sessionId Session identifier
    function execute(uint32 srcChainId, uint128 sessionId) public {
        // Check that the message has not be executed yet
        bytes32 memory uid = keccak256(abi.encodePacked(sessionId, 0));
        require(!this.executedMessages[uid], "already executed");

        // Read the message
        Mailbox.Metadata memory metadata = Mailbox.Metadata(
            srcChainId,
            mailbox.chain_id(),
            bytes32(remoteExecuterAddress[srcChainId]),
            bytes32(address(this)),
            sessionId,
            0
        );
        bytes memory payload = Mailbox.recv(metadata);

        // Call the function
        (address contractAddress, bytes memory callParams) = abi.decode(
            payload
        );
        contractAddress.call{gas: 100000}(callParams);

        // Mark message as executed
        this.executedMessages[uid] = true;
    }
}

// Contract deployed on chain A
contract Caller {
    /// @notice Function on the source chain A that calls a function of a 
    ///     contract deployed on the destination chain B
    /// @dev The identifier of the destination chain CHAIN_B_ID and the remote 
    ///     contract address FOO_CONTRACT_ADDRESS are hardcoded
    /// @param val parameter to be passed to the function Foo.fun(...)
    function callChainB(uint256 val) public {
        bytes memory callParams = abi.encodeCall(Foo.fun(val));
        RemoteExecuter.remoteCall(CHAIN_B_ID, FOO_CONTRACT_ADDRESS, callParams);
    }
}

/// Contract deployed on chain B
/// We assume this contract is deployed at the address FOO_CONTRACT_ADDRESS
/// This contract has a function that is called from chain A
contract Foo {
    function fun(uint256 parameter) public {
        require(parameter == 42);
    }
}

```

--------------------------------

### N-Quads Example

Source: https://eips.ethereum.org/EIPS/eip-6239

Example of N-Quads statements with graph labels.

```text
<http://example.org/entity/user1> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.org/entity/User> <http://example.org/graphs/example> .
<http://example.org/entity/user1> <http://example.org/property/name> "Alice" <http://example.org/graphs/example> .

```

--------------------------------

### wallet_sign example parameters

Source: https://eips.ethereum.org/EIPS/eip-7871

Example JSON-RPC parameters for a wallet_sign request using version '1.0' and a personal_sign request (type '0x45') with the message 'Hello world'.

```json
{
  "version": "1.0",
  "request": {
    "type": "0x45",
    "data": {
      "message": "Hello world"
    }
  }
}

```

--------------------------------

### RDF/JSON Example

Source: https://eips.ethereum.org/EIPS/eip-6239

Example of RDF/JSON representing a user with type and name properties.

```json
   {
 "http://example.org/entity/user1": {
   "http://www.w3.org/1999/02/22-rdf-syntax-ns#type": [
     "http://example.org/entity/User"
   ],
   "http://example.org/property/name": [
     "Alice"
   ]
 }
}

```

--------------------------------

### Shared fixture setup for ConfidentialPolicyVerdict tests

Source: https://eips.ethereum.org/EIPS/eip-8354

Sets up the registry, verifier, and guard, registers a domain, and updates the root. Also defines a helper to create a valid Verdict.

```Solidity
PolicyDomainRegistry registry;
ConfidentialPolicyVerdict guard;
MockVerifier verifier;

bytes32 constant DOMAIN = keccak256("acme-compliance");
bytes32 constant ROOT = keccak256("root-v1");
bytes32 constant PROGRAM = keccak256("interpreter-vkey");
address constant EXECUTOR = address(0xE0);

function setUp() public {
    vm.warp(1_700_000_000);
    registry = new PolicyDomainRegistry();
    verifier = new MockVerifier();
    guard = new ConfidentialPolicyVerdict(registry);
    registry.registerDomain(DOMAIN, address(0xA11CE), address(verifier), PROGRAM, 1 hours);
    registry.updateRoot(DOMAIN, ROOT);
}

function _verdict() internal view returns (Verdict memory v) {
    v = Verdict({
        agentId: 1,
        domainId: DOMAIN,
        policyRoot: ROOT,
        actionCommitment: keccak256("action"),
        executor: EXECUTOR,
        expiry: uint64(block.timestamp + 1 hours),
        nullifier: keccak256("nf-1"),
        decision: 1,
        policyKind: PolicyKind.ALLOWED
    });
}
```
Tokens:
Raw