
Ethereum represents the gateway to a worldwide, decentralized computing paradigm. This platform enables you to run decentralized applications (DApps) and smart contracts that have no central points of failure or control, integrate with a payment network, and operate on an open blockchain. With this practical guide, Andreas M. Antonopoulos and Gavin Wood provide everything you need to know about building smart contracts and DApps on Ethereum and other virtual-machine blockchains.

Discover why IBM, Microsoft, NASDAQ, and hundreds of other organizations are experimenting with Ethereum. This essential guide shows you how to develop the skills necessary to be an innovator in this growing and exciting new industry.

A guide to the operation and use of Ethereum and other EVM-compatible blockchains.

Mastering Ethereum


The story of the idealists, technologists, and opportunists fighting to bring cryptocurrency to the masses.

In their short history, Bitcoin and other cryptocurrencies have gone through booms, busts, and internecine wars, recently reaching a market valuation of more than $2 trillion. The central promise of crypto endures—vast fortunes made from decentralized networks not controlled by any single entity and not yet regulated by many governments.

The recent growth of crypto would have been all but impossible if not for a brilliant young man named Vitalik Buterin and his creation: Ethereum. In this book, Laura Shin takes readers inside the founding of this novel cryptocurrency network, which enabled users to launch their own new coins, thus creating a new crypto fever. She introduces readers to larger-than-life characters like Buterin, the Web3 wunderkind; his short-lived CEO, Charles Hoskinson; and Joe Lubin, a former Goldman Sachs VP who became one of crypto’s most well-known billionaires. Sparks fly as these outsized personalities fight for their piece of a seemingly limitless new business opportunity.

This fascinating book shows the crypto market for what it really is: a deeply personal struggle to influence the coming revolution in money, culture, and power.

Idealism, Greed, Lies, and the Making of the First Big Cryptocurrency Craze

The Cryptopians


Tokens - often referred to as cryptocurrencies - can represent anything from an asset to an access right, such as gold, diamonds, a fraction of a Picasso painting or an entry ticket to a concert. Tokens could also be used to reward social media contributions, incentivize the reduction of CO2 emissions, or even ones attention for watching an ad. While it has become easy to create a token, which is collectively managed by a public Web3 infrastructure like a blockchain network, the understanding of how to apply these tokens is still vague.

The industry keeps referring to “Blockchain” as different from “Bitcoin,” creating an artificial divide that is often misleading. There seems to be too little understanding about the fact that Bitcoin is a blockchain network, which is (a) globally managed by people who mostly do not know each other, and (b) enabled by the consensus protocol that (c) incentivizes all network actors for their contributions with a native token. The governance rules are tied to the minting of a native blockchain token. The Bitcoin token can, therefore, be seen as the currency of a distributed Internet tribe, called the Bitcoin network, where network actors are rewarded with Bitcoins, just as the Ether is the currency of the distributed Internet tribe Ethereum network, or Sia is the native currency of the Sia network. The Bitcoin network and other distributed ledgers all represent a collectively maintained public infrastructure and are the backbone of the next generation Internet, what the crypto community refers to as the Web3.

This book attempts to summarize existing knowledge about blockchain networks and other distributed ledgers as the backbone of the Web3, and contextualize the socio-economic implications of the Web3 applications such as smart contracts, tokens, and DAOs to the concepts of money, economics, governance and decentralized finance (DeFi).

Token Economy


Learn to Code Blockchain DApps By Building Simple Games

CryptoZombies is an interactive school that teaches you all things technical about blockchains. Learn to make smart contracts in Solidity or Libra by making your own crypto-collectibles game.

#1 Solidity Tutorial & Ethereum Blockchain Programming Course

CryptoZombies


More and more DeFi projects on Ethereum are getting hacked. This is your chance to join the party.

Each challenge can be considered standalone. Depending on the challenge, you should either stop the system from working, steal as much funds as you can, or do some other unexpected things.

Put your black hat on, and break some DeFi projects on Ethereum!

Damn Vulnerable DeFi


This is an interactive tutorial website for learning Vyper while building games using smart contracts, similar to Cryptozombies.

VyperFun


Blockchain is an exciting new discipline in Computer Science. It combines a wide array of skills from math and cryptography to social sciences and understanding organizations. Understanding blockchain decentralization and how/where to apply it is a brand new skill that very few have mastered.

You will build your skills from the ground up with strong fundamentals that will provide you with the ability to adapt in this rapidly evolving ecosystem.

Choose From Multiple Paths to Begin Your Ethereum Coding Journey.

Fast-track your Ethereum Developer career in an instructor-led and challenging bootcamp focused on discussion and application!

ChainShot


This is an initiative for the early solidity developers by those who were early developers sometime.

In this approach, we are looking to categorize the smart contract according to the difficulty level in multiple standards. For now, we are keeping the standard 0 to 5(can be discussed).

This initiative needs great support from Blockchain enthusiast, developer and researchers to build this school in a way which can attract learners and provide them ease for development.

First place for early developers to learn Solidity 

solidity-school


## Introductory Modules

- What is a SNARK?
- Building a SNARK (part 1)
- Building a SNARK (part 2)

## Whiteboard Sessions with ZK Projects​

- SNARKs vs. STARKS with Brendan and Bobbin
- PLONK and Custom Gates with Adrian Hamelink
- Lookup Arguments for Performance Optimisation with Mary Maller
- Zero Knowledge Virtual Machine (zkVM) with grjte
- Achieving Decentralised Private Computation with Pratyush Mishra
- Introduction to zkRollups with Barry Whitehat
- zkEVM with Jordi Baylina
- ZK Swaps with Henry de Valence
- zkID with Oleksandr Brezhniev
- Fast Recursion with Plonky2 with William Borgeaud

ZK Whiteboard Sessions is an educational series on all things zero knowledge

ZK Whiteboard Sessions


## What is a smart contract?

Smart contracts are the backbone of decentralized applications (DApps) and Web3. A smart contract is a simple program that lives on a blockchain network (such as Ethereum). They're actually not that smart. And nothing like a (legal) contract. They’re more like an executable piece of code that requires input or an trigger from an external source. They can validate those input conditions and if correct, execute their own logic to update the state on a blockchain.

## Benefits

They often serve the following purposes:
- Store and maintain data
- Manage relationships with users, or other contracts

Benefits of smart contracts are
- Immutable - once deployed none can change them
- Composable - they’re public and anyone can interact with them, or build on top of them. Much like public APIs

## Resources

The following resources have been the most popular resources on the site for a long time. These are all highly recommend to start learning about Solidity


### 1. Official Solidity website
The most obvious resources is ofcourse the official website and documentation of the Solidity team itself. The Solidity team covers all the core concepts and fundamentals of Solidity and smart contracts in general. Highly recommended

https://soliditylang.org/


### 2. Solidity by Example
The second one on the list is Solidity by Example. A great collection of more pratical examples, incl. source code and supporting videos.

https://solidity-by-example.org/


### 3. CryptoZombies 
CryptoZombies is an interactive school that teaches you all things technical about blockchains. A fun and interactive way to write smart contracts in Solidity by making your own crypto-collectibles game.

https://cryptozombies.io/


### 4. Speedrun Ethereum

Speedrun Ethereum helps you get to the next level. It teaches you how to build on Ethereum; the superpowers and the gotchas while you build up your Web3 portfolio. If you like this, also make sure to check out the other work of the amazing [Austin Griffith](https://twitter.com/austingriffith) such as [ETH-build](https://eth.build/) and [Scaffold-eth](https://scaffoldeth.io/).

https://speedrunethereum.com/


### 5. Smart Contract Best Practices 

Smart contracts are complex instruments that have the authority to allocate high-value resources between complex systems. Often working autonomously. With huge financial loss at risk. This makes them critical components in these systems. Development of such components requires thoughtful design, solid engineering practices, rigorous testing and a strong security mindset. This document provides a baseline knowledge of security considerations.

https://consensys.github.io/smart-contract-best-practices/


## Other resources

If you'd like to read more, make sure to checkout all the other [Solidity](/tags/smart%20contracts) resources on the site.

Solidity is a programming language designed for developing smart contracts that run on Ethereum. It's the most in demand skill in the Web3 space. These are the best resources to help you learn more about it.

Best resources to learn Solidity


This handbook is for people who are interested in exploring the vision behind “Web3”, and who wish to acquire in-demand skills that are essential to realizing that vision.  

A Handbook for Smart Contract Development

Learn Solidity

Free resources to learn about Zero Knowledge Proofs (ZKPs) and Cryptography

Road to ZK


Create Eth App supports multiple frontend frameworks. It comes with a host of decentralized finance templates pre-filled with contract ABIs, addresses and subgraphs. Everything you need to build a modern Ethereum-powered single-page app.

- Learning how to write Ethereum-powered apps in a comfortable and feature-rich development environment.
- Starting new Ethereum-powered single-page React applications without wasting time on copy-pasting boilerplates
- Creating examples with React for your Ethereum-related libraries and components.

Create Ethereum-powered apps with one command

Create Eth App


**Features**
- Next.js
- Ethereum
- Typescript
- Chakra UI
- Wagmi
- Connectkit
- Ethers.js

An open-source Next.js + Ethereum starter kit to quickly ship Web3 Apps

Nexth Starter kit


Everything you need to build on Ethereum!

Quickly experiment with Solidity using a frontend that adapts to your smart contract

Forkable Ethereum dev stack focused on fast product iterations

Scaffold-ETH


Becoming a blockchain engineer is the most fun, rewarding, and exhilarating choice I’ve and my colleagues have ever made. And we’ve already blazed the trail for you to get started! In this article, we will show you exactly how to learn to become a blockchain engineer, from beginner to professional.

Spoiler alert, here is the exact blueprint we are going to cover to get you to a successful blockchain engineer:

1. Understand why you should become a blockchain engineer
2. Take a Blockchain Course
3. Join a Hackathon, the Community, & Build
4. Start your own protocol, Take a job, Freelance & Contribute

If you make it this far, you’ve done it! Although, I’ll add a bonus step 5 that we will talk about soon.

5. You’ve made it! Keep learning!

That’s it! These are the exact steps you need to take to become a blockchain engineer!

Become a blockchain, solidity, and smart contract engineer by following these steps

Become a Blockchain Engineer


Odds are you’ve heard about the Ethereum blockchain, whether or not you know what it is. It’s been in the news a lot lately, including the cover of some major magazines, but reading those articles can be like gibberish if you don’t have a foundation for what exactly Ethereum is. So what is it? In essence, a public database that keeps a permanent record of digital transactions. Importantly, this database doesn’t require any central authority to maintain and secure it. Instead it operates as a “trustless” transactional system — a framework in which individuals can make peer-to-peer transactions without needing to trust a third party OR one another.

Still confused? That’s where this post comes in. My aim is to explain how Ethereum functions at a technical level, without complex math or scary-looking formulas. Even if you’re not a programmer, I hope you’ll walk away with at least better grasp of the tech. If some parts are too technical and difficult to grok, that’s totally fine! There’s really no need to understand every little detail. I recommend just focusing on understanding things at a broad level.

Many of the topics covered in this post are a breakdown of the concepts discussed in the yellow paper. I’ve added my own explanations and diagrams to make understanding Ethereum easier. Those brave enough to take on the technical challenge can also read the Ethereum yellow paper.

Many of the topics covered in this post are a breakdown of the concepts discussed in the yellow paper. I’ve added my own explanations and diagrams to make it easier.

How does Ethereum work, anyway?


I recently joined Edge & Node as a Developer Relations Engineer and have been diving deeper into smart contract development with Ethereum. I have settled upon what I think is the best stack for building full stack dApps with Solidity:

▶︎ Client Framework - React
▶︎ Ethereum development environment - Hardhat
▶︎ Ethereum Web Client Library - Ethers.js
▶︎ API layer - The Graph Protocol

Building Full Stack dApps with React, Ethers.js, Solidity, and Hardhat

The Complete Guide to Full Stack Ethereum Development


Educational sandbox for building on web3. Visually understand how Ethereum works by doing.

ETH.Build


https://www.youtube.com/watch?v=gyMwXuJrbJQ

This course will give you a full introduction into all of the core concepts in blockchain, smart contracts, solidity, NFTs/ERC721s, ERC20s, Coding Decentralized Finance (DeFi), javascript and solidity, Chainlink, Ethereum, upgradable smart contracts, and full stack blockchain development.   

Some of the technologies covered are:
- The Graph
- Chainlink
- Metamask
- Alchemy
- Remix
- Hardhat
- Solidity
- Openzeppelin
- Trail of Bits
- Ganache
- Ethers
- Etherscan
- Coinmarketcap
- Aave
- IPFS
- Fleek.hq
- Filecoin
- NextJS
- Moralis
- Web3uikit
- Opensea
- Pinata
- Nft.storage

 And more!

Follow along with the videos and you'll be a blockchain wizard in no time!  💻 The repository with helpful links to all code, resources, and support forums is located here: https://github.com/smartcontractkit/full-blockchain-solidity-course-js.

This course will give you a full introduction into all of the core concepts related to blockchain, smart contracts, Solidity, ERC20s, full-stack Web3 dapps, decentralized finance (DeFi), JavaScript, TypeScript, Chainlink, Ethereum, upgradable smart contracts, DAOs, the graph, moralis, aave, IPFS, and more. Follow along with the videos and you'll be a blockchain wizard in no time!

Learn Blockchain, Solidity, and Full Stack Web3 Development with JavaScript – 32-Hour Course


Learning Solidity with a collection of YouTube videos and example code.

Learning Solidity


Here we collect and discuss the best DeFi & Blockchain researches and tools 

DeFi Developer roadmap


Nowadays there are countless well-made resources on how to learn blockchain development of all kinds and with different specializations in mind, however, it is still very hard to get guidance and personalized suggestions based on your interests. I am writing this guide in order to provide an aggregator of all the resources that I’ve found over the years, plus give some opinionated commentary on how to approach them and how to use them in order to maximize learning and practical understanding in order to get building cool things in the space as soon as possible.

This guide will focus on the Ethereum ecosystem as that’s where most developers and applications are. If you are interested in other ecosystems that are non-EVM compatible and are not L2s on Ethereum, then check out their respective documentation or guides written by their developer communities. Examples of other non-EVM compatible blockchains that are popular are Solana (Rust/Anchor), Polkadot (Rust/Substrate), Cosmos, Terra, and others. Most of these blockchains do or will support the EVM stack through various initiatives like Neon EVM (Solana), Moonbeam/Moonriver (Polkadot/Kusama), EVMOS (Cosmos), etc.

I really want this guide to become a community-sourced public good that everyone will be able to take advantage of. I will do my best to present it to the wider blockchain developer community to get constructive feedback, proofreading help, and insight into how to make it the best available guide available.

devpill.me


This document provides a baseline knowledge of security considerations for intermediate Solidity programmers. It is maintained by ConsenSys Diligence, with contributions from our friends in the broader Ethereum community.

A guide to Ethereum smart contract security best practices

Smart Contract Best Practices

See https://github.com/foundry-rs/foundry/pull/1619

good first issue

A-forge

A-reference

T-new

A book on all things Foundry, available at https://book.getfoundry.sh.

book

Solidity

Document new `mockCall` and `expectCall` variants

## Task summary

- Currently, the file `dot/rpc/subscription/websocket_test.go` contains the test `TestWSConn_HandleComm` which tests all the websocket endpoint functions providing inputs and asserting the output. The problem is each test in the function depends on the previous test output and each test update the `Websocket Module` state, so becomes hard to include new tests.

- Refactor the test function to support test cases like https://github.com/ChainSafe/gossamer/blob/7d946fd86c1401b2de147f6971a1e59ee177df21/internal/trie/node/branch_encode_test.go#L16

Good First Issue

tests

W3F Approved

🕸️ Go Implementation of the Polkadot Host

gossamer

refactor `TestWSConn_HandleComm` to support test cases

We should expose the `Arch` class in python bindings so that users can use the generic `pc` and `sp` getters, and allow to get the size of an arbitrary register.

Contrary to the native C++ `Arch` API, the Python wrapper should use strings to identify registers, instead of `reg_t`, since it will integrate better with the way the CPU is exposed in bindings (with a dynamic attribute getter that uses the register names, rather than their `reg_t` number.

Acceptance criteria:
- `Arch` class is exposed in bindings with methods:
    - `pc()`: return the name of the program counter
    - `sp()`: return the name of the stack pointer
    - `reg_size(<reg>)`: return the size in bits of the register
- `MaatEngine` has an `arch` attribute accessible from python bindings  

bindings

idea

Good first issue

Open-source symbolic execution framework: https://maat.re

maat

Expose the `Arch` class in bindings

Hive and Hedera both use `.`s and `-`s in their native addresses-- there may also be corner-cases or testnets or checksums or other places where CAIP-10 is too constrictive.  Would be worth discussing:
- needs for and pro's of less constrictive CAIP-10
- costs and breakage to existing CAIP-10 tooling (did:pkh, didkit, walletconnect, etc)

It would be good to discuss this at our next meeting!

See https://github.com/ChainAgnostic/CAIPs/pull/95 and [the hedera/caip10.md file](https://github.com/ChainAgnostic/namespaces/pull/16/files#diff-7f076ba2ee91e09378704fe34b1023f9ee790633d93a801d791ba7105f3d03bdR20-R25)

help wanted

next meeting

CAIPs

HTML

Expanding and/or finalizing CAIP-10?

If you start a stack for development with "-e1", the sandbox is broken. It still tries to connect to a container named (for instance) `firefly_core_0`, which does not exist when using the "external" option.

firefly-cli

Sandbox does not work when using "-e1"

The AUR packages are used by Arch Linux. It looks some solidity core devs are using these. Include the `PKGBUILD` config here and test it on CI.

- https://aur.archlinux.org/packages/evmone
- https://wiki.archlinux.org/title/CMake_package_guidelines

cc @cameel

build

Fast Ethereum Virtual Machine implementation

evmone

Build and test AUR package

https://github.com/CarstenNZ/slither-wiki/blob/master/Detector-Documentation.md has a couple of fixes / typos in the detectors description.

We should merge them before the next release

Related https://github.com/crytic/slither/issues/1189

slither

Python

Fix typos in detectors documentation 

If we give Echidna valid ranges for enum types, it will spend less time producing invalid calldata and possibly help reach greater coverage (at the very least in less runs). For each contract, produce a list of valid ranges for each enum range.

TBD: 
what format would be ideal @ggrieco-tob?
```
"enum_ranges":
    "Contract": [
        "Status": 4,
    ]
```

enhancement

add enum size in echidna printer export

### Describe the desired feature

Echidna should be able to access implementation contracts via a proxy contract that utilizes delegatecall with msg.data. This will allow easier fuzzing on proxy contracts. Currently, the user needs to create a wrapper for each of the functions that are in the implementation contract. 

Ideally, the Slither printer would extract functions that use msg.data and associate the functions of the called contract into the calling contract. 

echidna

Identify Functions that use delegatecall and msg.data for Echidna Printer

Suggested by @LukaszRozmej 
_Could we change to have one property `SyncMode `with values from enumeration FullSync, FastSync, ~~PivotSync~~, SnapSync instead of bool flags FastSync, FastBlocks, SnapSync? Those are now exclusive flags and make configuration confusing._

Additionally:
The entire application code should not use old properties.
The properties should be marked as deprecated, setting them should cause a warning to be displayed

configuration

snap sync

Our flagship Ethereum execution client for Linux, Windows, and macOS — full and actively developed.

nethermind

Introduce SyncMode config property

Currently, we're using https://github.com/web3j/web3j-sokt/blob/master/src/main/resources/releases.json to install solidity.
This is not good as we need to release new versions of sokt, and most of the other libraries, whenever we have a new solc version so that we're up-to-date.

I suggest we:
- Either host the `releases.json` file somewhere (or even a very simple API to query the links), and we make a GET request call whenever we want to check for the versions.
- Find a repetitive pattern for the links and look for them dynamically when detecting a version in contracts:
   - For Linux binaries for example: `https://github.com/ethereum/solidity/releases/download/v<version>/solc-static-linux` seems to work

This would make our releases easier and also avoid the issues we're getting from users depending on libraries that use the latest solidity versions.

Kotlin-based wrapper for multiple installations of the solidity compiler (solc)

web3j-sokt

Kotlin

Use a different mechanism to fetch solc binaries links

I have some contracts using a library structure data storage, compiled using an older version of Solidity, but which throw an error asking me to make a report here.

In the `libraryType.sol` contract I have something like this:

```solidity
library PersonLib {
    struct Data {
        bool   isActive;
        bytes  hashOfData;
        string handle;
    }
    function handle(Data storage self) public view returns (string) {
        return self.handle;
    }
    function markActive(Data storage self) internal {
        self.isActive = true;
    }
    //other getters & setters omitted
}
```
In other contracts, the library contract is imported and the type of a variable or struct member might be `PersonLib.Data` - sometimes, there are more than one of the same type in the same file (e.g. a `Requester` and a `Contributor` with wrapper functions similar to this:
```solidity
    function requesterHandle() public view returns (string) {
        return requester.handle;
    }
    function updateRequesterHandle(string newHandle) public {
        emit RequesterHandleUpdated(newHandle);
        PersonLib.updateHandle(requester, newHandle);
    }
```
That works fine in Solidity, but when trying to generate types with TypeChain, that triggers an error like this:

>Could not parse type: PersonLib.Data storage with internal type: undefined.
>
>Please submit a GitHub Issue to the TypeChain team with the failing contract/library.

This error report is hereby filed per request.
Hopefully I haven't missed something important when attempting to make it a minimal example for the report.


🔌 TypeScript bindings for Ethereum smart contracts

TypeChain

TypeScript

Could not parse type with internal type: undefined for custom structure

## Task summary

- Currently, all unit tests within `dot/peerset` packages use `time.Sleep()` to wait for an action and then perform an assertion, would be nice to introduce an event-driven approach in order to remove the `time.Sleep()` dependency.


## Specification reference

- N/A



## Other information and links

- N/A

Type: Enhancement

Using an event-driven approach in `dot/peerset` unit tests

Besu needs DNS/IP:Port whereas others allow for just DNS and let the reverse proxy route them to the correct port. My reverse proxy forwards the traffic to the new ethstats server, but Besu doesn't like that since it tries to send traffic to the port 3000 of the specified DNS server (doesn't touch the reverse proxy then). 

So I can switch to IP:Port of the new server, but I'd say this is a QoL thing that should be fixed. 

### Acceptance Criteria
* Besu continues reporting to an Ethstats server that has changed it's ip/port under it's DNS entry.

### Steps to Reproduce (Bug)
1. Change the IP of a reverse proxy between Besu and Ethstats

**Expected behavior:** Reporting continues

**Actual behavior:** Reporting stops, error message in logs saying:

` Failed to reach the ethstats server finishConnect(..) failed: Connection refused: ethstats.mainnetshadowfork3.ethdevops.io/164.92.169.47:3000`




TeamGroot

An enterprise-grade Java-based, Apache 2.0 licensed Ethereum client https://wiki.hyperledger.org/display/besu

besu

Java

Improve DNS use from Ethstats

## Feature

Similar to #4461, it would be nice if people could `truffle exec` typescript without needing to run a compilation step.

## Steps to Reproduce

Write a script for `truffle exec` in TypeScript

## Desired Behavior

Truffle would use `ts-node` to execute said script

## Current Behavior

Users must first compile said script, and `truffle exec` the compilation output.


priority3 🔧

A tool for developing smart contracts. Crafted with the finest cacaos.

truffle

Truffle should allow people to specify their `truffle exec` scripts as typescript, without compilation

When `solang --standard-json` is run, the output from the compiler is in the [standard json](https://docs.soliditylang.org/en/v0.8.13/using-the-compiler.html#compiler-input-and-output-json-description) format. However, the input is not.

1) Parse input on stdin as json using the [standard json](https://docs.soliditylang.org/en/v0.8.13/using-the-compiler.html#compiler-input-and-output-json-description) format
2) Make sure the input described in 1) is compiled and result is printed using standard json (that last part is already implemented).
3) Write tests for this feature

Note that changing this feature will break the burrow tests. The burrow tests can be disabled for now, since [burrow](https://github.com/hyperledger/burrow) is a dead project.

Solidity Compiler for Solana and Substrate

solang

Rust

solang needs to accept solidity standard json as input

In aries-rfcs [0454 Present Proof v2.1](https://github.com/hyperledger/aries-rfcs/tree/main/features/0454-present-proof-v2) the [request-presentation message](https://github.com/hyperledger/aries-rfcs/tree/main/features/0454-present-proof-v2#request-presentation) includes the boolean element `present_multiple` which is intended to cause the prover to include all credentials which meet the conditions of a `request-presentation` message when it is set to `true`.  ACA-Py does not currently support this feature.  The purpose of this feature request is to implement changes to allow ACA-Py to understand and respond appropriately when this value is `true`.

Example case:

Roles:

  - Alice: Issues credentials to Bob
  - Bob: Holds credentials and proves them upon request
  - Cook: Requests verifications from Bob

Assume Alice can issue multiple "food" credentials to Bob.  A food credential has the following characteristics:

  - attributes: [name, meal, is_favorite]

Alice issues the following credentials to Bob.

```
[
  {
    "name": "scrambled eggs",
    "is_favorite": false,
    "meal": "breakfast"
  },
  {
    "name": "cookie crisp",
    "is_favorite": true,
    "meal": "breakfast"
  },
  {
    "name": "ham sandwich",
    "is_favorite": true,
    "meal": "lunch"
  },
  {
    "name": "fried rice",
    "is_favorite": true,
    "meal": "dinner"
  },
  {
    "name": "boiled cabbage",
    "is_favorite": false,
    "meal": "dinner"
  }
]
```

When Cook uses the Present Proof v2 protocol to ask Bob about his credentials we could imagine the following cases:

  1. Cook asks what are Bob's favorite foods.  Bob returns the information for "cookie crisp", "ham sandwich", and "fried rice".
  2. Cook asks what Bob can have for dinner.  Bob returns the information for "fried rice" and "boiled cabbage".
  3. Cook asks what Bob has as favorite foods for breakfast.  Bob returns the information for "cookie crisp" only.


Hyperledger Aries Cloud Agent Python (ACA-Py) is a foundation for building decentralized identity applications and services running in non-mobile environments.

aries-cloudagent-python

Support Aries RFC 454 present_proof v2.1 -- sending multiple presentations in a single protocol instance

**Describe the bug**
Previously, I could `dotnet build ...` on my machine without any problems.  Now when I try I get the following error:
```
  ---> Generating Git Hash file Before Build
  'git' is not recognized as an internal or external command,
  operable program or batch file.
C:\...\src\Nethermind\Nethermind.Runner\Nethermind.Runner.csproj(119,5): error MSB3073: The command "git describe --tags --long --always > git-hash" exited with code 9009.
```

**To Reproduce**
Steps to reproduce the behavior:
1. Install Windows 11
2. Install dotnet SDK
3. Acquire Nethermind source code
4. `cd src/Nethermind`
5. `dotnet build --configuration Release Nethermind.sln`
6. Notice that the build fails

**Expected behavior**
I don't need any tooling besides `dotnet` to build.

**Desktop (please complete the following information):**
 - OS: Windows
 - Version: `1.12.8`

**Additional context**
While I do have `git` installed, I don't have it on my path because I *never* use it from the CLI, I always use it from higher level tooling.

low priority

Remove hard dependency on `git` CLI available to the build system.

In the [description of @truffle/contract](https://www.npmjs.com/package/@truffle/contract) under "Calling getters" the documentation makes clear you can do something like
```js
instance.getValue.call().then(function(val) {
  // val represents the `value` storage object in the solidity contract
  // since the contract returns that value.
});
```
It notes that `.call()` is optional, but I believe making this explicit is often a good idea. Unfortunately, with the types generated by this library, the `.call()` is not a valid syntax, because invoking the generic `.call()` on the `CallableFunction` being assumed here requires passing a `this` argument as a first parameter, and `.call()` doesn't have that.

I would propose adding a `call()` similar to what is found on non-`view` functions.

call() not being generated on view fns

Hi,
I would like to use `maat` with simple projects but I have troubles running, for instance, `id`. My code is the following:

```
from maat import *
m = MaatEngine(ARCH.X64, OS.LINUX)  
m.load("/bin/id", BIN.ELF64, libdirs=["/usr/lib/x86_64-linux-gnu/"])
m.run()
```

and the output is the following

```
➜  maat python3 id.py
[Info] Adding object 'ld-linux-x86-64.so.2' to virtual fs at '/usr/lib/ld-linux-x86-64.so.2'
[Info] Adding object 'libc.so.6' to virtual fs at '/usr/lib/libc.so.6'
[Info] Adding object 'libdl.so.2' to virtual fs at '/usr/lib/libdl.so.2'
[Info] Adding object 'libpcre2-8.so.0' to virtual fs at '/usr/lib/libpcre2-8.so.0'
[Info] Adding object 'libpthread.so.0' to virtual fs at '/usr/lib/libpthread.so.0'
[Info] Adding object 'libselinux.so.1' to virtual fs at '/usr/lib/libselinux.so.1'
[Info] Adding object 'id' to virtual fs at '/id'
[Error] Exception in CALLOTHER handler: SYSCALL: EnvEmulator: syscall '218' not supported for emulation
[Error] Unexpected error when processing IR instruction, aborting...
➜  maat 
```

Would it be hard to add the support for the missing system call?

Thanks

Contribute to open-source Web3 projects

✨ Ethereum.org

✨ Privacy & Scaling Explorations

✨ Solidity