juanblanco/Nethereum.ABIv5.8.0

docs d<> code .compare c

✓ Verified.NET FW4.5.1.NET FW4.6.1.NET 6.0.NET 8.0

Encoding and decoding of ABI Types, functions, events of Ethereum contracts

nethereum.com ↗

License

View license

Deps

Install Size

—

Vulns

✓ 0

Published

Jan 6, 2026

Get Started

$ dotnet add package Nethereum.ABI

Readme

Nethereum.ABI

Encoding and decoding of ABI Types, functions, events of Ethereum contracts

Overview

Nethereum.ABI is the core package for Ethereum's Application Binary Interface (ABI) encoding and decoding in .NET. It provides comprehensive support for encoding function calls, decoding function outputs, processing event logs, EIP-712 typed data signing, and handling all Solidity data types including complex structures like tuples and dynamic arrays.

This package is fundamental to all smart contract interactions in Nethereum, as it translates between .NET objects and the binary format Ethereum uses for contract communication.

Installation

dotnet add package Nethereum.ABI

Dependencies

Nethereum:

Nethereum.Hex - Hexadecimal encoding/decoding
Nethereum.Util - Keccak-256 hashing and utilities

Key Concepts

Application Binary Interface (ABI)

The ABI is a JSON specification that describes:

Functions: Input parameters, output parameters, and function signatures
Events: Indexed and non-indexed parameters for log filtering and decoding
Errors: Custom error types and their parameters
Types: Complete type system including elementary types, arrays, structs (tuples)

Function Encoding

Function calls are encoded as:

Function Selector: First 4 bytes of Keccak-256 hash of the function signature
Encoded Parameters: ABI-encoded input parameters (32-byte aligned)

Event Decoding

Events are stored in transaction logs with:

Topics: Up to 4 indexed parameters (including event signature hash)
Data: Non-indexed parameters (ABI-encoded)

EIP-712 Typed Data

Structured data hashing and signing standard that enables:

Human-readable signatures: Users can see what they're signing
Domain separation: Prevents replay attacks across different dApps
Typed structs: Support for complex nested data structures
Used by: MetaMask, Permit (EIP-2612), Uniswap, OpenSea, and many more

Type System

Nethereum.ABI supports all Solidity types:

Elementary: uint256, int256, address, bool, bytes, bytesN, string
Fixed Arrays: uint256[20], address[5]
Dynamic Arrays: uint256[], string[]
Tuples: Complex structs with nested components

Quick Start

Basic Function Encoding

using Nethereum.ABI.FunctionEncoding;
using Nethereum.ABI.Model;

// Create encoder
var functionCallEncoder = new FunctionCallEncoder();

// Define function signature and parameters
var sha3Signature = "c6888fa1";  // First 8 hex chars of Keccak-256("functionName(paramTypes)")
var parameters = new[]
{
    new Parameter("address", "recipient"),
    new Parameter("uint256", "amount")
};

// Encode function call
string encoded = functionCallEncoder.EncodeRequest(
    sha3Signature,
    parameters,
    "0x1234567890abcdef1234567890abcdef12345678",  // recipient
    1000000000000000000  // amount (1 ETH in wei)
);
// Result: "0xc6888fa10000000000000000000000001234567890abcdef1234567890abcdef12345678000000000000000000000000000000000000000000000000001e4c89d6c7e400"

Decoding Function Output

// From test: FunctionEncodingTests.cs
var functionCallDecoder = new FunctionCallDecoder();

var outputParameters = new[]
{
    new ParameterOutput()
    {
        Parameter = new Parameter("uint[]", "numbers")
        {
            DecodedType = typeof(List<int>)
        }
    }
};

var result = functionCallDecoder.DecodeOutput(
    "0x0000000000000000000000000000000000000000000000000000000000000020" +
    "0000000000000000000000000000000000000000000000000000000000000003" +
    "0000000000000000000000000000000000000000000000000000000000000000" +
    "0000000000000000000000000000000000000000000000000000000000000001" +
    "0000000000000000000000000000000000000000000000000000000000000002",
    outputParameters
);

var numbers = (List<int>)result[0].Result;
// numbers: [0, 1, 2]

Usage Examples

Example 1: Encoding Multiple Types Including Dynamic Strings

From test: FunctionEncodingTests.cs:125

using Nethereum.ABI.FunctionEncoding;
using Nethereum.ABI.Model;

var functionCallEncoder = new FunctionCallEncoder();
var sha3Signature = "c6888fa1";

var inputsParameters = new[]
{
    new Parameter("string", "greeting"),
    new Parameter("uint[20]", "numbers"),
    new Parameter("string", "farewell")
};

var array = new uint[20];
for (uint i = 0; i < 20; i++)
    array[i] = i + 234567;

string encoded = functionCallEncoder.EncodeRequest(
    sha3Signature,
    inputsParameters,
    "hello",      // Dynamic string (pointer to data)
    array,        // Fixed-size array (inline)
    "world"       // Dynamic string (pointer to data)
);

// Result starts with function selector, followed by:
// - Pointer to "hello" data
// - 20 uint256 values inline
// - Pointer to "world" data
// - Actual "hello" string data
// - Actual "world" string data

Example 2: Attribute-Based Function Encoding

From test: FunctionAttributeEncodingTests.cs:55

using Nethereum.ABI.FunctionEncoding;
using Nethereum.ABI.FunctionEncoding.Attributes;

[Function("multiply")]
public class MultiplyFunction : FunctionMessage
{
    [Parameter("uint256", "a", 1)]
    public int A { get; set; }
}

var input = new MultiplyFunction { A = 69 };
var encoder = new FunctionCallEncoder();
string encoded = encoder.EncodeRequest(input, "c6888fa1");

// Result: "0xc6888fa10000000000000000000000000000000000000000000000000000000000000045"
// 69 decimal = 0x45 hex, padded to 32 bytes

Example 3: Decoding Event Topics (Transfer Event)

From test: EventTopicDecoderTests.cs:13

using Nethereum.ABI.FunctionEncoding;
using Nethereum.ABI.FunctionEncoding.Attributes;
using System.Numerics;

[Event("Transfer")]
public class TransferEvent
{
    [Parameter("address", "_from", 1, indexed: true)]
    public string From { get; set; }

    [Parameter("address", "_to", 2, indexed: true)]
    public string To { get; set; }

    [Parameter("uint256", "_value", 3, indexed: true)]
    public BigInteger Value { get; set; }
}

var topics = new[]
{
    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",  // Event signature
    "0x0000000000000000000000000000000000000000000000000000000000000000",  // from (zero address)
    "0x000000000000000000000000c14934679e71ef4d18b6ae927fe2b953c7fd9b91",  // to
    "0x0000000000000000000000000000000000000000000000400000402000000001"   // value
};

var data = "0x";  // No non-indexed data

var transferEvent = new TransferEvent();
new EventTopicDecoder().DecodeTopics(transferEvent, topics, data);

// transferEvent.From: "0x0000000000000000000000000000000000000000"
// transferEvent.To: "0xc14934679e71ef4d18b6ae927fe2b953c7fd9b91"
// transferEvent.Value: 1180591691223594434561

Example 4: Simple ABI Encoding with ABIEncode

From test: AbiEncodeTests.cs:12

using Nethereum.ABI;
using Nethereum.Hex.HexConvertors.Extensions;

var abiEncode = new ABIEncode();

// Encode multiple values with explicit types
byte[] encoded = abiEncode.GetABIEncoded(
    new ABIValue("string", "hello"),
    new ABIValue("int", 69),
    new ABIValue("string", "world")
);

string hexResult = encoded.ToHex(true);
// Result: "0x0000000000000000000000000000000000000000000000000000000000000060..."
// Includes pointers to dynamic data and the actual string data

Example 5: Encoding with Parameter Attributes

From test: AbiEncodeTests.cs:34

using Nethereum.ABI;
using Nethereum.ABI.FunctionEncoding.Attributes;

public class TestParamsInput
{
    [Parameter("string", 1)]
    public string First { get; set; }

    [Parameter("int256", 2)]
    public int Second { get; set; }

    [Parameter("string", 3)]
    public string Third { get; set; }
}

var abiEncode = new ABIEncode();
var input = new TestParamsInput
{
    First = "hello",
    Second = 69,
    Third = "world"
};

byte[] encoded = abiEncode.GetABIParamsEncoded(input);
// Automatically encodes based on Parameter attributes

Example 6: Deserializing Contract ABI JSON

From test: FunctionAttributeEncodingTests.cs:14

using Nethereum.ABI.ABIDeserialisation;
using System.Linq;

var abi = @"[
    {
        ""constant"": false,
        ""inputs"": [{""name"": ""a"", ""type"": ""uint256""}],
        ""name"": ""multiply"",
        ""outputs"": [{""name"": ""d"", ""type"": ""uint256""}],
        ""type"": ""function""
    }
]";

var deserializer = new ABIJsonDeserialiser();
var contract = deserializer.DeserialiseContract(abi);

var multiplyFunction = contract.Functions.FirstOrDefault(x => x.Name == "multiply");
// multiplyFunction.Sha3Signature: "c6888fa1"
// multiplyFunction.Constant: false
// multiplyFunction.InputParameters[0].Type: "uint256"

Example 7: Complex Tuples with Nested Arrays

From test: AbiDeserialiseTuplesTests.cs:22

using Nethereum.ABI.ABIDeserialisation;
using System.Linq;

// Complex ABI with nested tuple containing array of tuples
var abi = @"[{
    ""constant"": false,
    ""inputs"": [{
        ""components"": [
            {""name"": ""id"", ""type"": ""uint256""},
            {
                ""components"": [
                    {""name"": ""id"", ""type"": ""uint256""},
                    {""name"": ""productId"", ""type"": ""uint256""},
                    {""name"": ""quantity"", ""type"": ""uint256""}
                ],
                ""name"": ""lineItem"",
                ""type"": ""tuple[]""
            },
            {""name"": ""customerId"", ""type"": ""uint256""}
        ],
        ""name"": ""purchaseOrder"",
        ""type"": ""tuple""
    }],
    ""name"": ""SetPurchaseOrder"",
    ""outputs"": [],
    ""type"": ""function""
}]";

var contractAbi = new ABIJsonDeserialiser().DeserialiseContract(abi);
var functionABI = contractAbi.Functions.FirstOrDefault(e => e.Name == "SetPurchaseOrder");

// Function signature includes full tuple structure
// functionABI.Sha3Signature: "0cc400bd"

Example 8: Encoding Individual Types

From test: FunctionEncodingTests.cs:79-107

using Nethereum.ABI.FunctionEncoding;
using Nethereum.ABI.Model;

var encoder = new FunctionCallEncoder();
var signature = "c6888fa1";

// Address encoding
var addressParam = new[] { new Parameter("address", "recipient") };
string encodedAddress = encoder.EncodeRequest(
    signature,
    addressParam,
    "0x1234567890abcdef1234567890abcdef12345678"
);
// Result: "0xc6888fa10000000000000000000000001234567890abcdef1234567890abcdef12345678"

// Boolean encoding
var boolParam = new[] { new Parameter("bool", "flag") };
string encodedBool = encoder.EncodeRequest(signature, boolParam, true);
// Result: "0xc6888fa10000000000000000000000000000000000000000000000000000000000000001"

// Integer encoding
var intParam = new[] { new Parameter("int", "number") };
string encodedInt = encoder.EncodeRequest(signature, intParam, 69);
// Result: "0xc6888fa10000000000000000000000000000000000000000000000000000000000000045"
// Note: 69 decimal = 0x45 hex

Example 9: EIP-712 Typed Data with Simple Structs

From test: Eip712TypedDataSignerSimpleScenarioTest.cs:66

using Nethereum.ABI.EIP712;
using Nethereum.ABI.FunctionEncoding.Attributes;
using Nethereum.Signer.EIP712;
using System.Collections.Generic;

// Define your domain-specific structs
[Struct("Person")]
public class Person
{
    [Parameter("string", "name", 1)]
    public string Name { get; set; }

    [Parameter("address[]", "wallets", 2)]
    public List<string> Wallets { get; set; }
}

[Struct("Mail")]
public class Mail
{
    [Parameter("tuple", "from", 1, "Person")]
    public Person From { get; set; }

    [Parameter("tuple[]", "to", 2, "Person[]")]
    public List<Person> To { get; set; }

    [Parameter("string", "contents", 3)]
    public string Contents { get; set; }
}

// Create typed data definition
var typedData = new TypedData<Domain>
{
    Domain = new Domain
    {
        Name = "Ether Mail",
        Version = "1",
        ChainId = 1,
        VerifyingContract = "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"
    },
    Types = MemberDescriptionFactory.GetTypesMemberDescription(typeof(Domain), typeof(Mail), typeof(Person)),
    PrimaryType = nameof(Mail),
};

// Create message
var mail = new Mail
{
    From = new Person
    {
        Name = "Cow",
        Wallets = new List<string>
        {
            "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826",
            "0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF"
        }
    },
    To = new List<Person>
    {
        new Person
        {
            Name = "Bob",
            Wallets = new List<string>
            {
                "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB",
                "0xB0BdaBea57B0BDABeA57b0bdABEA57b0BDabEa57",
                "0xB0B0b0b0b0b0B000000000000000000000000000"
            }
        }
    },
    Contents = "Hello, Bob!"
};

// Set the message
typedData.SetMessage(mail);

// Sign using private key
var signer = new Eip712TypedDataSigner();
var key = new EthECKey("94e001d6adf3a3275d5dd45971c2a5f6637d3e9c51f9693f2e678f649e164fa5");
string signature = signer.SignTypedDataV4(mail, typedData, key);
// signature: "0x943393c998ab7e067d2875385e2218c9b3140f563694267ac9f6276a9fcc53e1..."

// Recover signer address from signature
string recoveredAddress = signer.RecoverFromSignatureV4(mail, typedData, signature);
// recoveredAddress matches key.GetPublicAddress()

Example 10: EIP-712 Typed Data from JSON

From test: Eip712TypedDataSignerTest.cs:107

using Nethereum.ABI.EIP712;
using Nethereum.Signer.EIP712;

// EIP-712 typed data as JSON (MetaMask format)
var typedDataJson = @"{
    'domain': {
        'chainId': 1,
        'name': 'Ether Mail',
        'verifyingContract': '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
        'version': '1'
    },
    'message': {
        'contents': 'Hello, Bob!',
        'from': {
            'name': 'Cow',
            'wallets': [
                '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
                '0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF'
            ]
        },
        'to': [{
            'name': 'Bob',
            'wallets': [
                '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
                '0xB0BdaBea57B0BDABeA57b0bdABEA57b0BDabEa57',
                '0xB0B0b0b0b0b0B000000000000000000000000000'
            ]
        }]
    },
    'primaryType': 'Mail',
    'types': {
        'EIP712Domain': [
            {'name': 'name', 'type': 'string'},
            {'name': 'version', 'type': 'string'},
            {'name': 'chainId', 'type': 'uint256'},
            {'name': 'verifyingContract', 'type': 'address'}
        ],
        'Mail': [
            {'name': 'from', 'type': 'Person'},
            {'name': 'to', 'type': 'Person[]'},
            {'name': 'contents', 'type': 'string'}
        ],
        'Person': [
            {'name': 'name', 'type': 'string'},
            {'name': 'wallets', 'type': 'address[]'}
        ]
    }
}";

// Deserialize and encode
var rawTypedData = TypedDataRawJsonConversion.DeserialiseJsonToRawTypedData(typedDataJson);
var signer = new Eip712TypedDataSigner();
byte[] encodedTypedData = signer.EncodeTypedDataRaw(rawTypedData);

// Sign directly from JSON
var key = new EthECKey("94e001d6adf3a3275d5dd45971c2a5f6637d3e9c51f9693f2e678f649e164fa5");
string signature = signer.SignTypedDataV4(rawTypedData, key);

Example 11: EIP-712 with Complex Nested Structures

From test: EIP712TypeDataSignatureMultipleComplexInnerObjects.cs:13

using Nethereum.ABI.EIP712;
using Nethereum.ABI.FunctionEncoding.Attributes;
using System.Collections.Generic;
using System.Numerics;

[Struct("UsageLimit")]
public class UsageLimit
{
    [Parameter("uint8", "limitType", 1)]
    public byte LimitType { get; set; }

    [Parameter("uint256", "limit", 2)]
    public BigInteger Limit { get; set; }

    [Parameter("uint256", "period", 3)]
    public BigInteger Period { get; set; }
}

[Struct("Constraint")]
public class Constraint
{
    [Parameter("uint8", "condition", 1)]
    public byte Condition { get; set; }

    [Parameter("uint64", "index", 2)]
    public ulong Index { get; set; }

    [Parameter("bytes32", "refValue", 3)]
    public byte[] RefValue { get; set; }
}

[Struct("CallSpec")]
public class CallSpec
{
    [Parameter("address", "target", 1)]
    public string Target { get; set; }

    [Parameter("bytes4", "selector", 2)]
    public byte[] Selector { get; set; }

    [Parameter("uint256", "maxValuePerUse", 3)]
    public BigInteger MaxValuePerUse { get; set; }

    [Parameter("tuple", "valueLimit", 4, structTypeName: "UsageLimit")]
    public UsageLimit ValueLimit { get; set; }

    [Parameter("tuple[]", "constraints", 5, structTypeName: "Constraint[]")]
    public List<Constraint> Constraints { get; set; }
}

[Struct("SessionSpec")]
public class SessionSpec
{
    [Parameter("address", "signer", 1)]
    public string Signer { get; set; }

    [Parameter("uint256", "expiresAt", 2)]
    public BigInteger ExpiresAt { get; set; }

    [Parameter("tuple[]", "callPolicies", 3, structTypeName: "CallSpec[]")]
    public List<CallSpec> CallPolicies { get; set; }
}

// This demonstrates deep nesting: SessionSpec contains array of CallSpec,
// each CallSpec contains UsageLimit struct and array of Constraint structs
// Perfect for complex DeFi protocols, account abstraction, session keys, etc.

Example 12: EIP-712 Encoding and Hashing

From test: Eip712TypedDataEncoder.cs

using Nethereum.ABI.EIP712;
using Nethereum.Hex.HexConvertors.Extensions;

var encoder = new Eip712TypedDataEncoder();

// Encode from typed data
var mail = new Mail { /* ... */ };
var typedData = new TypedData<Domain> { /* ... */ };
byte[] encoded = encoder.EncodeTypedData(mail, typedData);

// Encode and hash in one operation (for signing)
byte[] hash = encoder.EncodeAndHashTypedData(mail, typedData);

// Encode directly from JSON
string json = /* EIP-712 JSON */;
byte[] encodedFromJson = encoder.EncodeTypedData(json);
byte[] hashFromJson = encoder.EncodeAndHashTypedData(json);

// The hash is what gets signed with ECDSA
string hashHex = hash.ToHex(true);

Example 13: Error Handling for Invalid Parameters

From test: FunctionEncodingTests.cs:161

using Nethereum.ABI.FunctionEncoding;
using Nethereum.ABI.Model;

var encoder = new FunctionCallEncoder();
var signature = "c6888fa1";
var parameters = new[] { new Parameter("address", "_address1") };

try
{
    string encoded = encoder.EncodeRequest(signature, parameters, (object)null);
}
catch (AbiEncodingException ex)
{
    // ex.Message: "An error occurred encoding abi value. Order: '1', Type: 'address',
    //              Value: 'null'. Ensure the value is valid for the abi type."
    Console.WriteLine(ex.Message);
}

API Reference

Core Classes

`ABIEncode`

GetABIEncoded(params ABIValue[] abiValues) - Encode values with explicit types
GetABIEncoded(params object[] values) - Encode values with automatic type detection
GetABIParamsEncoded<T>(T input) - Encode object using Parameter attributes
GetABIEncodedPacked(params ABIValue[] abiValues) - Packed encoding (no padding)
GetSha3ABIEncoded(...) - Encode and hash in one operation

`FunctionCallEncoder`

EncodeRequest(string sha3Signature, Parameter[] parameters, params object[] values) - Encode function call
EncodeRequest<T>(T functionInput, string sha3Signature) - Encode using attributes

`FunctionCallDecoder`

DecodeOutput(string output, params Parameter[] parameters) - Decode function return values
DecodeFunctionOutput<T>(string output) - Decode using attributes

`EventTopicDecoder`

DecodeTopics(object destination, string[] topics, string data) - Decode event log into object
DecodeTopics<T>(string[] topics, string data) - Decode event log to typed object

`ABIJsonDeserialiser`

DeserialiseContract(string abi) - Parse contract ABI JSON
DeserialiseContract(JArray abi) - Parse from JArray
Produces ContractABI with Functions, Events, Errors, Constructor

`Eip712TypedDataEncoder`

EncodeTypedData<T, TDomain>(T message, TypedData<TDomain> typedData) - Encode typed data with message
EncodeTypedData(string json) - Encode from EIP-712 JSON
EncodeAndHashTypedData(...) - Encode and hash for signing
EncodeTypedDataRaw(TypedDataRaw typedData) - Low-level encoding

`Eip712TypedDataSigner` (in Nethereum.Signer)

SignTypedDataV4<T>(T message, TypedData<Domain> typedData, EthECKey key) - Sign EIP-712 data
RecoverFromSignatureV4<T>(T message, TypedData<Domain> typedData, string signature) - Recover signer
SignTypedDataV4(TypedDataRaw typedData, EthECKey key) - Sign from raw typed data

Encoding Attributes

[Function("name")] - Mark class as function definition
[Event("name")] - Mark class as event definition
[Struct("name")] - Mark class as EIP-712 struct
[Parameter("type", "name", order, indexed)] - Mark property as parameter
[FunctionOutput] - Mark class can be used for output decoding

EIP-712 Classes

TypedData<TDomain> - Typed data with domain separation
Domain - EIP-712 domain (name, version, chainId, verifyingContract, salt)
MemberDescription - Type member definition (name, type)
MemberDescriptionFactory - Generate type descriptions from .NET types
MemberValue - Runtime value for encoding
TypedDataRaw - Raw typed data without generics

Related Packages

Nethereum.Hex - Hexadecimal encoding used throughout ABI operations
Nethereum.Util - Keccak-256 hashing for function/event signatures
Nethereum.Signer - EIP-712 signing and signature recovery
Nethereum.Contracts - High-level contract interaction built on ABI encoding
Nethereum.RPC - JSON-RPC calls that use ABI-encoded data

Important Notes

Function Signature Calculation

Function signatures are the first 4 bytes of Keccak-256 hash of the canonical function signature:

Keccak256("transfer(address,uint256)") → 0xa9059cbb2ab09eb219583f4a59a5d0623ade346d962bcd4e46b11da047c9049b
Function selector: 0xa9059cbb (first 4 bytes)

Event Signature Calculation

Event signatures are the full 32 bytes of Keccak-256 hash of the canonical event signature:

Keccak256("Transfer(address,address,uint256)") → 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
Event topic[0]: Full hash (identifies the event)

EIP-712 Domain Separation

The domain separator prevents signature replay attacks across:

Different contracts (via verifyingContract address)
Different chains (via chainId)
Different versions (via version)
Different applications (via name)

Formula: Keccak256(encodeData("EIP712Domain", domain))

EIP-712 Structured Data Hash

Final hash signed by user:

Keccak256("\x19\x01" + domainSeparator + hashStruct(message))

Where:

\x19\x01 is the version byte for structured data
domainSeparator is the hash of the domain
hashStruct(message) is the hash of the primary message type

Dynamic vs Static Types

Static types (uint256, address, bool, bytesN, fixed arrays): Encoded inline
Dynamic types (string, bytes, dynamic arrays, tuples with dynamic members): Encoded as pointer + data

Type Canonicalization

When calculating signatures, types must be canonical:

uint → uint256
int → int256
No spaces: transfer(address,uint256) not transfer(address, uint256)

Indexed Event Parameters

Maximum 3 indexed parameters per event (topic[0] is always event signature)
Indexed parameters are searchable/filterable in logs
Non-indexed parameters are cheaper and stored in data field

EIP-712 Use Cases

MetaMask Sign-In: Authenticate users without gas
EIP-2612 Permit: Gasless token approvals (USDC, DAI, UNI)
OpenSea/NFT Marketplaces: Off-chain order signing
Uniswap Permit2: Advanced approval management
Account Abstraction: Session keys and delegated operations
DAO Voting: Off-chain vote collection with on-chain execution

Playground Examples

Runnable examples available at Nethereum Playground:

Human-Readable ABI:

Example 1069 - Deployment, calls, and transactions using human-readable ABI format

ABI Encoding:

Example 1070 - Encoding using ABI Values, Parameters and Default values
Example 1071 - ABI Encoding Packed using ABI Values
Example 1072 - ABI Encoding Packed using parameters
Example 1073 - ABI Encoding Packed using default values

Resources

Total Downloads

12.4M

Compatibility

.NET FW4.5.1

.NET FW4.6.1

.NET 6.0

.NET 8.0

.NET 9.0

.NET Std2.0

Versions

5.8.0Latest

Jan 6, 2026

Other versions (73)

5.0.0May 28, 2025

4.29.0Feb 10, 2025

4.28.0Jan 7, 2025

4.27.1Dec 24, 2024

4.27.0Dec 24, 2024

4.26.0Oct 1, 2024

4.25.0Sep 19, 2024

4.21.4Aug 9, 2024

4.21.3Jul 22, 2024

4.21.2Jun 26, 2024

4.21.1Jun 26, 2024

4.21.0Jun 18, 2024

4.20.0Mar 28, 2024

4.19.0Feb 16, 2024

4.18.0Nov 21, 2023

4.17.1Sep 28, 2023

4.17.0Sep 27, 2023

4.16.0Aug 14, 2023

4.15.2Jul 11, 2023

4.15.1Jul 11, 2023

4.15.0Jul 11, 2023

4.14.0Mar 19, 2023

4.13.0Feb 18, 2023

4.12.0Dec 9, 2022

4.11.0Oct 27, 2022

4.9.0Sep 27, 2022

4.8.0Aug 24, 2022

4.7.0Jul 20, 2022

4.6.1Jun 18, 2022

4.6.0Jun 16, 2022

4.5.0May 13, 2022

4.4.1Apr 27, 2022

4.4.0Apr 27, 2022

4.3.0Apr 12, 2022

4.2.0Feb 18, 2022

4.1.1Nov 4, 2021

4.1.0Oct 15, 2021

4.0.5Aug 12, 2021

4.0.4Aug 10, 2021

4.0.3Aug 8, 2021

4.0.2Aug 5, 2021

4.0.1Jul 28, 2021

4.0.0Jul 26, 2021

3.8.0Jul 3, 2020

3.7.1Feb 13, 2020

3.7.0Feb 13, 2020

3.6.0Jan 27, 2020

3.5.0Dec 31, 2019

3.4.0Jul 29, 2019

3.3.0Apr 23, 2019

3.2.0Apr 8, 2019

3.1.2Mar 13, 2019

3.1.1Mar 12, 2019

3.1.0Mar 12, 2019

3.0.0Nov 28, 2018

2.5.1Jun 5, 2018

2.5.0Jun 4, 2018

2.4.0Mar 11, 2018

2.3.1Mar 7, 2018

2.3.0Mar 6, 2018

2.2.3Dec 16, 2017

2.2.2Dec 16, 2017

2.2.0Dec 8, 2017

2.1.0Oct 23, 2017

2.0.1Oct 4, 2017

2.0.0Sep 26, 2017

1.0.6Feb 3, 2017

1.0.5Jan 31, 2017

1.0.4Dec 10, 2016

1.0.3Nov 28, 2016

1.0.2Nov 21, 2016

1.0.1Oct 31, 2016

1.0.0Sep 14, 2016

Nethereum.ABI

Encoding and decoding of ABI Types, functions, events of Ethereum contracts

Overview

This package is fundamental to all smart contract interactions in Nethereum, as it translates between .NET objects and the binary format Ethereum uses for contract communication.

Installation

dotnet add package Nethereum.ABI

Dependencies

Nethereum:

Nethereum.Hex - Hexadecimal encoding/decoding
Nethereum.Util - Keccak-256 hashing and utilities

Key Concepts

Application Binary Interface (ABI)

The ABI is a JSON specification that describes:

Functions: Input parameters, output parameters, and function signatures
Events: Indexed and non-indexed parameters for log filtering and decoding
Errors: Custom error types and their parameters
Types: Complete type system including elementary types, arrays, structs (tuples)

Function Encoding

Function calls are encoded as:

Function Selector: First 4 bytes of Keccak-256 hash of the function signature
Encoded Parameters: ABI-encoded input parameters (32-byte aligned)

Event Decoding

Events are stored in transaction logs with:

Topics: Up to 4 indexed parameters (including event signature hash)
Data: Non-indexed parameters (ABI-encoded)

EIP-712 Typed Data

Structured data hashing and signing standard that enables:

Human-readable signatures: Users can see what they're signing
Domain separation: Prevents replay attacks across different dApps
Typed structs: Support for complex nested data structures
Used by: MetaMask, Permit (EIP-2612), Uniswap, OpenSea, and many more

Type System

Nethereum.ABI supports all Solidity types:

Elementary: uint256, int256, address, bool, bytes, bytesN, string
Fixed Arrays: uint256[20], address[5]
Dynamic Arrays: uint256[], string[]
Tuples: Complex structs with nested components

Quick Start

Basic Function Encoding

using Nethereum.ABI.FunctionEncoding;
using Nethereum.ABI.Model;

// Create encoder
var functionCallEncoder = new FunctionCallEncoder();

// Define function signature and parameters
var sha3Signature = "c6888fa1";  // First 8 hex chars of Keccak-256("functionName(paramTypes)")
var parameters = new[]
{
    new Parameter("address", "recipient"),
    new Parameter("uint256", "amount")
};

// Encode function call
string encoded = functionCallEncoder.EncodeRequest(
    sha3Signature,
    parameters,
    "0x1234567890abcdef1234567890abcdef12345678",  // recipient
    1000000000000000000  // amount (1 ETH in wei)
);
// Result: "0xc6888fa10000000000000000000000001234567890abcdef1234567890abcdef12345678000000000000000000000000000000000000000000000000001e4c89d6c7e400"

Decoding Function Output

// From test: FunctionEncodingTests.cs
var functionCallDecoder = new FunctionCallDecoder();

var outputParameters = new[]
{
    new ParameterOutput()
    {
        Parameter = new Parameter("uint[]", "numbers")
        {
            DecodedType = typeof(List<int>)
        }
    }
};

var result = functionCallDecoder.DecodeOutput(
    "0x0000000000000000000000000000000000000000000000000000000000000020" +
    "0000000000000000000000000000000000000000000000000000000000000003" +
    "0000000000000000000000000000000000000000000000000000000000000000" +
    "0000000000000000000000000000000000000000000000000000000000000001" +
    "0000000000000000000000000000000000000000000000000000000000000002",
    outputParameters
);

var numbers = (List<int>)result[0].Result;
// numbers: [0, 1, 2]

Usage Examples

Example 1: Encoding Multiple Types Including Dynamic Strings

From test: FunctionEncodingTests.cs:125

using Nethereum.ABI.FunctionEncoding;
using Nethereum.ABI.Model;

var functionCallEncoder = new FunctionCallEncoder();
var sha3Signature = "c6888fa1";

var inputsParameters = new[]
{
    new Parameter("string", "greeting"),
    new Parameter("uint[20]", "numbers"),
    new Parameter("string", "farewell")
};

var array = new uint[20];
for (uint i = 0; i < 20; i++)
    array[i] = i + 234567;

string encoded = functionCallEncoder.EncodeRequest(
    sha3Signature,
    inputsParameters,
    "hello",      // Dynamic string (pointer to data)
    array,        // Fixed-size array (inline)
    "world"       // Dynamic string (pointer to data)
);

// Result starts with function selector, followed by:
// - Pointer to "hello" data
// - 20 uint256 values inline
// - Pointer to "world" data
// - Actual "hello" string data
// - Actual "world" string data

Example 2: Attribute-Based Function Encoding

From test: FunctionAttributeEncodingTests.cs:55

using Nethereum.ABI.FunctionEncoding;
using Nethereum.ABI.FunctionEncoding.Attributes;

[Function("multiply")]
public class MultiplyFunction : FunctionMessage
{
    [Parameter("uint256", "a", 1)]
    public int A { get; set; }
}

var input = new MultiplyFunction { A = 69 };
var encoder = new FunctionCallEncoder();
string encoded = encoder.EncodeRequest(input, "c6888fa1");

// Result: "0xc6888fa10000000000000000000000000000000000000000000000000000000000000045"
// 69 decimal = 0x45 hex, padded to 32 bytes

Example 3: Decoding Event Topics (Transfer Event)

From test: EventTopicDecoderTests.cs:13

using Nethereum.ABI.FunctionEncoding;
using Nethereum.ABI.FunctionEncoding.Attributes;
using System.Numerics;

[Event("Transfer")]
public class TransferEvent
{
    [Parameter("address", "_from", 1, indexed: true)]
    public string From { get; set; }

    [Parameter("address", "_to", 2, indexed: true)]
    public string To { get; set; }

    [Parameter("uint256", "_value", 3, indexed: true)]
    public BigInteger Value { get; set; }
}

var topics = new[]
{
    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",  // Event signature
    "0x0000000000000000000000000000000000000000000000000000000000000000",  // from (zero address)
    "0x000000000000000000000000c14934679e71ef4d18b6ae927fe2b953c7fd9b91",  // to
    "0x0000000000000000000000000000000000000000000000400000402000000001"   // value
};

var data = "0x";  // No non-indexed data

var transferEvent = new TransferEvent();
new EventTopicDecoder().DecodeTopics(transferEvent, topics, data);

// transferEvent.From: "0x0000000000000000000000000000000000000000"
// transferEvent.To: "0xc14934679e71ef4d18b6ae927fe2b953c7fd9b91"
// transferEvent.Value: 1180591691223594434561

Example 4: Simple ABI Encoding with ABIEncode

From test: AbiEncodeTests.cs:12

using Nethereum.ABI;
using Nethereum.Hex.HexConvertors.Extensions;

var abiEncode = new ABIEncode();

// Encode multiple values with explicit types
byte[] encoded = abiEncode.GetABIEncoded(
    new ABIValue("string", "hello"),
    new ABIValue("int", 69),
    new ABIValue("string", "world")
);

string hexResult = encoded.ToHex(true);
// Result: "0x0000000000000000000000000000000000000000000000000000000000000060..."
// Includes pointers to dynamic data and the actual string data

Example 5: Encoding with Parameter Attributes

From test: AbiEncodeTests.cs:34

using Nethereum.ABI;
using Nethereum.ABI.FunctionEncoding.Attributes;

public class TestParamsInput
{
    [Parameter("string", 1)]
    public string First { get; set; }

    [Parameter("int256", 2)]
    public int Second { get; set; }

    [Parameter("string", 3)]
    public string Third { get; set; }
}

var abiEncode = new ABIEncode();
var input = new TestParamsInput
{
    First = "hello",
    Second = 69,
    Third = "world"
};

byte[] encoded = abiEncode.GetABIParamsEncoded(input);
// Automatically encodes based on Parameter attributes

Example 6: Deserializing Contract ABI JSON

From test: FunctionAttributeEncodingTests.cs:14

using Nethereum.ABI.ABIDeserialisation;
using System.Linq;

var abi = @"[
    {
        ""constant"": false,
        ""inputs"": [{""name"": ""a"", ""type"": ""uint256""}],
        ""name"": ""multiply"",
        ""outputs"": [{""name"": ""d"", ""type"": ""uint256""}],
        ""type"": ""function""
    }
]";

var deserializer = new ABIJsonDeserialiser();
var contract = deserializer.DeserialiseContract(abi);

var multiplyFunction = contract.Functions.FirstOrDefault(x => x.Name == "multiply");
// multiplyFunction.Sha3Signature: "c6888fa1"
// multiplyFunction.Constant: false
// multiplyFunction.InputParameters[0].Type: "uint256"

Example 7: Complex Tuples with Nested Arrays

From test: AbiDeserialiseTuplesTests.cs:22

using Nethereum.ABI.ABIDeserialisation;
using System.Linq;

// Complex ABI with nested tuple containing array of tuples
var abi = @"[{
    ""constant"": false,
    ""inputs"": [{
        ""components"": [
            {""name"": ""id"", ""type"": ""uint256""},
            {
                ""components"": [
                    {""name"": ""id"", ""type"": ""uint256""},
                    {""name"": ""productId"", ""type"": ""uint256""},
                    {""name"": ""quantity"", ""type"": ""uint256""}
                ],
                ""name"": ""lineItem"",
                ""type"": ""tuple[]""
            },
            {""name"": ""customerId"", ""type"": ""uint256""}
        ],
        ""name"": ""purchaseOrder"",
        ""type"": ""tuple""
    }],
    ""name"": ""SetPurchaseOrder"",
    ""outputs"": [],
    ""type"": ""function""
}]";

var contractAbi = new ABIJsonDeserialiser().DeserialiseContract(abi);
var functionABI = contractAbi.Functions.FirstOrDefault(e => e.Name == "SetPurchaseOrder");

// Function signature includes full tuple structure
// functionABI.Sha3Signature: "0cc400bd"

Example 8: Encoding Individual Types

From test: FunctionEncodingTests.cs:79-107

using Nethereum.ABI.FunctionEncoding;
using Nethereum.ABI.Model;

var encoder = new FunctionCallEncoder();
var signature = "c6888fa1";

// Address encoding
var addressParam = new[] { new Parameter("address", "recipient") };
string encodedAddress = encoder.EncodeRequest(
    signature,
    addressParam,
    "0x1234567890abcdef1234567890abcdef12345678"
);
// Result: "0xc6888fa10000000000000000000000001234567890abcdef1234567890abcdef12345678"

// Boolean encoding
var boolParam = new[] { new Parameter("bool", "flag") };
string encodedBool = encoder.EncodeRequest(signature, boolParam, true);
// Result: "0xc6888fa10000000000000000000000000000000000000000000000000000000000000001"

// Integer encoding
var intParam = new[] { new Parameter("int", "number") };
string encodedInt = encoder.EncodeRequest(signature, intParam, 69);
// Result: "0xc6888fa10000000000000000000000000000000000000000000000000000000000000045"
// Note: 69 decimal = 0x45 hex

Example 9: EIP-712 Typed Data with Simple Structs

From test: Eip712TypedDataSignerSimpleScenarioTest.cs:66

using Nethereum.ABI.EIP712;
using Nethereum.ABI.FunctionEncoding.Attributes;
using Nethereum.Signer.EIP712;
using System.Collections.Generic;

// Define your domain-specific structs
[Struct("Person")]
public class Person
{
    [Parameter("string", "name", 1)]
    public string Name { get; set; }

    [Parameter("address[]", "wallets", 2)]
    public List<string> Wallets { get; set; }
}

[Struct("Mail")]
public class Mail
{
    [Parameter("tuple", "from", 1, "Person")]
    public Person From { get; set; }

    [Parameter("tuple[]", "to", 2, "Person[]")]
    public List<Person> To { get; set; }

    [Parameter("string", "contents", 3)]
    public string Contents { get; set; }
}

// Create typed data definition
var typedData = new TypedData<Domain>
{
    Domain = new Domain
    {
        Name = "Ether Mail",
        Version = "1",
        ChainId = 1,
        VerifyingContract = "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"
    },
    Types = MemberDescriptionFactory.GetTypesMemberDescription(typeof(Domain), typeof(Mail), typeof(Person)),
    PrimaryType = nameof(Mail),
};

// Create message
var mail = new Mail
{
    From = new Person
    {
        Name = "Cow",
        Wallets = new List<string>
        {
            "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826",
            "0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF"
        }
    },
    To = new List<Person>
    {
        new Person
        {
            Name = "Bob",
            Wallets = new List<string>
            {
                "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB",
                "0xB0BdaBea57B0BDABeA57b0bdABEA57b0BDabEa57",
                "0xB0B0b0b0b0b0B000000000000000000000000000"
            }
        }
    },
    Contents = "Hello, Bob!"
};

// Set the message
typedData.SetMessage(mail);

// Sign using private key
var signer = new Eip712TypedDataSigner();
var key = new EthECKey("94e001d6adf3a3275d5dd45971c2a5f6637d3e9c51f9693f2e678f649e164fa5");
string signature = signer.SignTypedDataV4(mail, typedData, key);
// signature: "0x943393c998ab7e067d2875385e2218c9b3140f563694267ac9f6276a9fcc53e1..."

// Recover signer address from signature
string recoveredAddress = signer.RecoverFromSignatureV4(mail, typedData, signature);
// recoveredAddress matches key.GetPublicAddress()

Example 10: EIP-712 Typed Data from JSON

From test: Eip712TypedDataSignerTest.cs:107

using Nethereum.ABI.EIP712;
using Nethereum.Signer.EIP712;

// EIP-712 typed data as JSON (MetaMask format)
var typedDataJson = @"{
    'domain': {
        'chainId': 1,
        'name': 'Ether Mail',
        'verifyingContract': '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
        'version': '1'
    },
    'message': {
        'contents': 'Hello, Bob!',
        'from': {
            'name': 'Cow',
            'wallets': [
                '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
                '0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF'
            ]
        },
        'to': [{
            'name': 'Bob',
            'wallets': [
                '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
                '0xB0BdaBea57B0BDABeA57b0bdABEA57b0BDabEa57',
                '0xB0B0b0b0b0b0B000000000000000000000000000'
            ]
        }]
    },
    'primaryType': 'Mail',
    'types': {
        'EIP712Domain': [
            {'name': 'name', 'type': 'string'},
            {'name': 'version', 'type': 'string'},
            {'name': 'chainId', 'type': 'uint256'},
            {'name': 'verifyingContract', 'type': 'address'}
        ],
        'Mail': [
            {'name': 'from', 'type': 'Person'},
            {'name': 'to', 'type': 'Person[]'},
            {'name': 'contents', 'type': 'string'}
        ],
        'Person': [
            {'name': 'name', 'type': 'string'},
            {'name': 'wallets', 'type': 'address[]'}
        ]
    }
}";

// Deserialize and encode
var rawTypedData = TypedDataRawJsonConversion.DeserialiseJsonToRawTypedData(typedDataJson);
var signer = new Eip712TypedDataSigner();
byte[] encodedTypedData = signer.EncodeTypedDataRaw(rawTypedData);

// Sign directly from JSON
var key = new EthECKey("94e001d6adf3a3275d5dd45971c2a5f6637d3e9c51f9693f2e678f649e164fa5");
string signature = signer.SignTypedDataV4(rawTypedData, key);

Example 11: EIP-712 with Complex Nested Structures

From test: EIP712TypeDataSignatureMultipleComplexInnerObjects.cs:13

using Nethereum.ABI.EIP712;
using Nethereum.ABI.FunctionEncoding.Attributes;
using System.Collections.Generic;
using System.Numerics;

[Struct("UsageLimit")]
public class UsageLimit
{
    [Parameter("uint8", "limitType", 1)]
    public byte LimitType { get; set; }

    [Parameter("uint256", "limit", 2)]
    public BigInteger Limit { get; set; }

    [Parameter("uint256", "period", 3)]
    public BigInteger Period { get; set; }
}

[Struct("Constraint")]
public class Constraint
{
    [Parameter("uint8", "condition", 1)]
    public byte Condition { get; set; }

    [Parameter("uint64", "index", 2)]
    public ulong Index { get; set; }

    [Parameter("bytes32", "refValue", 3)]
    public byte[] RefValue { get; set; }
}

[Struct("CallSpec")]
public class CallSpec
{
    [Parameter("address", "target", 1)]
    public string Target { get; set; }

    [Parameter("bytes4", "selector", 2)]
    public byte[] Selector { get; set; }

    [Parameter("uint256", "maxValuePerUse", 3)]
    public BigInteger MaxValuePerUse { get; set; }

    [Parameter("tuple", "valueLimit", 4, structTypeName: "UsageLimit")]
    public UsageLimit ValueLimit { get; set; }

    [Parameter("tuple[]", "constraints", 5, structTypeName: "Constraint[]")]
    public List<Constraint> Constraints { get; set; }
}

[Struct("SessionSpec")]
public class SessionSpec
{
    [Parameter("address", "signer", 1)]
    public string Signer { get; set; }

    [Parameter("uint256", "expiresAt", 2)]
    public BigInteger ExpiresAt { get; set; }

    [Parameter("tuple[]", "callPolicies", 3, structTypeName: "CallSpec[]")]
    public List<CallSpec> CallPolicies { get; set; }
}

// This demonstrates deep nesting: SessionSpec contains array of CallSpec,
// each CallSpec contains UsageLimit struct and array of Constraint structs
// Perfect for complex DeFi protocols, account abstraction, session keys, etc.

Example 12: EIP-712 Encoding and Hashing

From test: Eip712TypedDataEncoder.cs

using Nethereum.ABI.EIP712;
using Nethereum.Hex.HexConvertors.Extensions;

var encoder = new Eip712TypedDataEncoder();

// Encode from typed data
var mail = new Mail { /* ... */ };
var typedData = new TypedData<Domain> { /* ... */ };
byte[] encoded = encoder.EncodeTypedData(mail, typedData);

// Encode and hash in one operation (for signing)
byte[] hash = encoder.EncodeAndHashTypedData(mail, typedData);

// Encode directly from JSON
string json = /* EIP-712 JSON */;
byte[] encodedFromJson = encoder.EncodeTypedData(json);
byte[] hashFromJson = encoder.EncodeAndHashTypedData(json);

// The hash is what gets signed with ECDSA
string hashHex = hash.ToHex(true);

Example 13: Error Handling for Invalid Parameters

From test: FunctionEncodingTests.cs:161

using Nethereum.ABI.FunctionEncoding;
using Nethereum.ABI.Model;

var encoder = new FunctionCallEncoder();
var signature = "c6888fa1";
var parameters = new[] { new Parameter("address", "_address1") };

try
{
    string encoded = encoder.EncodeRequest(signature, parameters, (object)null);
}
catch (AbiEncodingException ex)
{
    // ex.Message: "An error occurred encoding abi value. Order: '1', Type: 'address',
    //              Value: 'null'. Ensure the value is valid for the abi type."
    Console.WriteLine(ex.Message);
}

API Reference

Core Classes

`ABIEncode`

GetABIEncoded(params ABIValue[] abiValues) - Encode values with explicit types
GetABIEncoded(params object[] values) - Encode values with automatic type detection
GetABIParamsEncoded<T>(T input) - Encode object using Parameter attributes
GetABIEncodedPacked(params ABIValue[] abiValues) - Packed encoding (no padding)
GetSha3ABIEncoded(...) - Encode and hash in one operation

`FunctionCallEncoder`

EncodeRequest(string sha3Signature, Parameter[] parameters, params object[] values) - Encode function call
EncodeRequest<T>(T functionInput, string sha3Signature) - Encode using attributes

`FunctionCallDecoder`

DecodeOutput(string output, params Parameter[] parameters) - Decode function return values
DecodeFunctionOutput<T>(string output) - Decode using attributes

`EventTopicDecoder`

DecodeTopics(object destination, string[] topics, string data) - Decode event log into object
DecodeTopics<T>(string[] topics, string data) - Decode event log to typed object

`ABIJsonDeserialiser`

DeserialiseContract(string abi) - Parse contract ABI JSON
DeserialiseContract(JArray abi) - Parse from JArray
Produces ContractABI with Functions, Events, Errors, Constructor

`Eip712TypedDataEncoder`

EncodeTypedData<T, TDomain>(T message, TypedData<TDomain> typedData) - Encode typed data with message
EncodeTypedData(string json) - Encode from EIP-712 JSON
EncodeAndHashTypedData(...) - Encode and hash for signing
EncodeTypedDataRaw(TypedDataRaw typedData) - Low-level encoding

`Eip712TypedDataSigner` (in Nethereum.Signer)

SignTypedDataV4<T>(T message, TypedData<Domain> typedData, EthECKey key) - Sign EIP-712 data
RecoverFromSignatureV4<T>(T message, TypedData<Domain> typedData, string signature) - Recover signer
SignTypedDataV4(TypedDataRaw typedData, EthECKey key) - Sign from raw typed data

Encoding Attributes

[Function("name")] - Mark class as function definition
[Event("name")] - Mark class as event definition
[Struct("name")] - Mark class as EIP-712 struct
[Parameter("type", "name", order, indexed)] - Mark property as parameter
[FunctionOutput] - Mark class can be used for output decoding

EIP-712 Classes

TypedData<TDomain> - Typed data with domain separation
Domain - EIP-712 domain (name, version, chainId, verifyingContract, salt)
MemberDescription - Type member definition (name, type)
MemberDescriptionFactory - Generate type descriptions from .NET types
MemberValue - Runtime value for encoding
TypedDataRaw - Raw typed data without generics

Related Packages

Nethereum.Hex - Hexadecimal encoding used throughout ABI operations
Nethereum.Util - Keccak-256 hashing for function/event signatures
Nethereum.Signer - EIP-712 signing and signature recovery
Nethereum.Contracts - High-level contract interaction built on ABI encoding
Nethereum.RPC - JSON-RPC calls that use ABI-encoded data

Important Notes

Function Signature Calculation

Function signatures are the first 4 bytes of Keccak-256 hash of the canonical function signature:

Keccak256("transfer(address,uint256)") → 0xa9059cbb2ab09eb219583f4a59a5d0623ade346d962bcd4e46b11da047c9049b
Function selector: 0xa9059cbb (first 4 bytes)

Event Signature Calculation

Event signatures are the full 32 bytes of Keccak-256 hash of the canonical event signature:

Keccak256("Transfer(address,address,uint256)") → 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
Event topic[0]: Full hash (identifies the event)

EIP-712 Domain Separation

The domain separator prevents signature replay attacks across:

Different contracts (via verifyingContract address)
Different chains (via chainId)
Different versions (via version)
Different applications (via name)

Formula: Keccak256(encodeData("EIP712Domain", domain))

EIP-712 Structured Data Hash

Final hash signed by user:

Keccak256("\x19\x01" + domainSeparator + hashStruct(message))

Where:

\x19\x01 is the version byte for structured data
domainSeparator is the hash of the domain
hashStruct(message) is the hash of the primary message type

Dynamic vs Static Types

Static types (uint256, address, bool, bytesN, fixed arrays): Encoded inline
Dynamic types (string, bytes, dynamic arrays, tuples with dynamic members): Encoded as pointer + data

Type Canonicalization

When calculating signatures, types must be canonical:

uint → uint256
int → int256
No spaces: transfer(address,uint256) not transfer(address, uint256)

Indexed Event Parameters

Maximum 3 indexed parameters per event (topic[0] is always event signature)
Indexed parameters are searchable/filterable in logs
Non-indexed parameters are cheaper and stored in data field

EIP-712 Use Cases

MetaMask Sign-In: Authenticate users without gas
EIP-2612 Permit: Gasless token approvals (USDC, DAI, UNI)
OpenSea/NFT Marketplaces: Off-chain order signing
Uniswap Permit2: Advanced approval management
Account Abstraction: Session keys and delegated operations
DAO Voting: Off-chain vote collection with on-chain execution

Playground Examples

Runnable examples available at Nethereum Playground:

Human-Readable ABI:

Example 1069 - Deployment, calls, and transactions using human-readable ABI format

ABI Encoding:

Example 1070 - Encoding using ABI Values, Parameters and Default values
Example 1071 - ABI Encoding Packed using ABI Values
Example 1072 - ABI Encoding Packed using parameters
Example 1073 - ABI Encoding Packed using default values

juanblanco/Nethereum.ABIv5.8.0

Get Started

Readme

Nethereum.ABI

Overview

Installation

Dependencies

Key Concepts

Application Binary Interface (ABI)

Function Encoding

Event Decoding

EIP-712 Typed Data

Type System

Quick Start

Basic Function Encoding

Decoding Function Output

Usage Examples

Example 1: Encoding Multiple Types Including Dynamic Strings

Example 2: Attribute-Based Function Encoding

Example 3: Decoding Event Topics (Transfer Event)

Example 4: Simple ABI Encoding with ABIEncode

Example 5: Encoding with Parameter Attributes

Example 6: Deserializing Contract ABI JSON

Example 7: Complex Tuples with Nested Arrays

Example 8: Encoding Individual Types

Example 9: EIP-712 Typed Data with Simple Structs

Example 10: EIP-712 Typed Data from JSON

Example 11: EIP-712 with Complex Nested Structures

Example 12: EIP-712 Encoding and Hashing

Example 13: Error Handling for Invalid Parameters

API Reference

Core Classes

ABIEncode

FunctionCallEncoder

FunctionCallDecoder

EventTopicDecoder

ABIJsonDeserialiser

Eip712TypedDataEncoder

Eip712TypedDataSigner (in Nethereum.Signer)

Encoding Attributes

EIP-712 Classes

Related Packages

Important Notes

Function Signature Calculation

Event Signature Calculation

EIP-712 Domain Separation

EIP-712 Structured Data Hash

Dynamic vs Static Types

Type Canonicalization

Indexed Event Parameters

EIP-712 Use Cases

Playground Examples

Resources

juanblanco/Nethereum.ABIv5.8.0

Get Started

Readme

Nethereum.ABI

Overview

Installation

Dependencies

Key Concepts

Application Binary Interface (ABI)

Function Encoding

Event Decoding

EIP-712 Typed Data

Type System

Quick Start

Basic Function Encoding

Decoding Function Output

Usage Examples

Example 1: Encoding Multiple Types Including Dynamic Strings

Example 2: Attribute-Based Function Encoding

Example 3: Decoding Event Topics (Transfer Event)

Example 4: Simple ABI Encoding with ABIEncode

Example 5: Encoding with Parameter Attributes

Example 6: Deserializing Contract ABI JSON

Example 7: Complex Tuples with Nested Arrays

Example 8: Encoding Individual Types

Example 9: EIP-712 Typed Data with Simple Structs

Example 10: EIP-712 Typed Data from JSON

`ABIEncode`

`FunctionCallEncoder`

`FunctionCallDecoder`

`EventTopicDecoder`

`ABIJsonDeserialiser`

`Eip712TypedDataEncoder`

`Eip712TypedDataSigner` (in Nethereum.Signer)

`ABIEncode`

`FunctionCallEncoder`

`FunctionCallDecoder`

`EventTopicDecoder`

`ABIJsonDeserialiser`

`Eip712TypedDataEncoder`

`Eip712TypedDataSigner` (in Nethereum.Signer)