Built In Standards

dotnet add package Nethereum.Web3

var erc20 = web3.Eth.ERC20.GetContractService(tokenAddress);

var name = await erc20.NameQueryAsync();
var symbol = await erc20.SymbolQueryAsync();
var decimals = await erc20.DecimalsQueryAsync();
var totalSupply = await erc20.TotalSupplyQueryAsync();
var balance = await erc20.BalanceOfQueryAsync(ownerAddress);
var allowance = await erc20.AllowanceQueryAsync(owner, spender);

// Transfer
var receipt = await erc20.TransferRequestAndWaitForReceiptAsync(to, amount);

var erc721 = web3.Eth.ERC721.GetContractService(nftAddress);

var name = await erc721.NameQueryAsync();
var symbol = await erc721.SymbolQueryAsync();
var balance = await erc721.BalanceOfQueryAsync(ownerAddress);
var owner = await erc721.OwnerOfQueryAsync(tokenId);
var tokenUri = await erc721.TokenURIQueryAsync(tokenId);

var erc1155 = web3.Eth.ERC1155.GetContractService(contractAddress);

var balance = await erc1155.BalanceOfQueryAsync(owner, tokenId);
var balances = await erc1155.BalanceOfBatchQueryAsync(owners, tokenIds);
var uri = await erc1155.UriQueryAsync(tokenId);

var erc165 = web3.Eth.ERC165.GetContractService(contractAddress);

var supportsErc721 = await erc165
    .SupportsInterfaceQueryAsync("0x80ac58cd"); // ERC-721 interface ID

var supportsErc1155 = await erc165
    .SupportsInterfaceQueryAsync("0xd9b67a26"); // ERC-1155 interface ID

// Common interface IDs: ERC-165=0x01ffc9a7, ERC-721=0x80ac58cd, ERC-1155=0xd9b67a26

var erc1271 = web3.Eth.ERC1271.GetContractService(contractAddress);

var isValid = await erc1271
    .IsValidSignatureAndValidateReturnQueryAsync(messageHash, signature);

var isValid = await web3.Eth.ERC6492
    .IsValidSignatureQueryAsync(contractAddress, messageHash, signature);

var eip3009 = web3.Eth.EIP3009.GetContractService(usdcAddress);
var receipt = await eip3009.TransferWithAuthorizationRequestAndWaitForReceiptAsync(
    from, to, value, validAfter, validBefore, nonce, v, r, s);

using Nethereum.X402.Blockchain;
using Nethereum.X402.Models;
using Nethereum.X402.Signers;

// Build authorization + sign with EIP-712
var builder = new TransferWithAuthorisationBuilder();
var authorization = builder.BuildFromPaymentRequirements(requirements, payerAddress);
var signer = new TransferWithAuthorisationSigner();
var signature = await signer.SignWithPrivateKeyAsync(
    authorization, "USDC", "2", chainId, usdcAddress, privateKey);

// Verify + settle (x402 v2: only an RPC endpoint per chain id is configured)
var clients = new Dictionary<int, IClient> { [84532] = new RpcClient(new Uri(rpcUrl)) };
var service = new X402TransferWithAuthorisation3009Service(facilitatorKey, clients);
var result = await service.VerifyPaymentAsync(paymentPayload, requirements);
var settlement = await service.SettlePaymentAsync(paymentPayload, requirements);

// ReceiveWithAuthorization (receiver pays gas)
var receiveService = new X402ReceiveWithAuthorisation3009Service(receiverKey, clients);

using Nethereum.Contracts.Standards.Permit2;

var permit2 = web3.Eth.GetPermit2Service();

// Reads
var domainSeparator = await permit2.DomainSeparatorQueryAsync();
var allowance = await permit2.AllowanceQueryAsync(owner, token, spender);   // (amount, expiration, nonce)

// SignatureTransfer: the owner's signature is produced with Nethereum.Signer.EIP712's PermitSigner.
// The on-chain `permit` tuple omits spender (Permit2 uses msg.sender); the signed message includes it.
var receipt = await permit2.PermitTransferFromRequestAndWaitForReceiptAsync(
    permit,                                                    // PermitTransferFrom { permitted, nonce, deadline }
    new SignatureTransferDetails { To = recipient, RequestedAmount = amount },
    owner,
    signature);

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

var signature = PermitSigner.SignPermitTransferFrom(
    chainId, CommonAddresses.PERMIT2_ADDRESS,
    new PermitTransferFromWithSpender
    {
        Permitted = new TokenPermissions { Token = token, Amount = amount },
        Spender = spender,   // the caller; hashed as msg.sender on-chain
        Nonce = nonce,
        Deadline = deadline
    },
    key);

var ensService = web3.Eth.GetEnsService();
var address = await ensService.ResolveAddressAsync("vitalik.eth");
var name = await ensService.ReverseResolveAsync(address);
var url = await ensService.ResolveTextAsync("vitalik.eth", TextDataKey.url);

var universalResolver = web3.Eth.GetEnsUniversalResolverService();
var record = await universalResolver.ResolveRecordAsync("nick.eth", TextDataKey.url, TextDataKey.avatar);
var records = await universalResolver.ResolveRecordsAsync(new[] { "nick.eth", "nethereum.eth" }, TextDataKey.url);

var blockParam = new Nethereum.RPC.Eth.DTOs.BlockParameter(15000000);
var historicalBalance = await erc20.BalanceOfQueryAsync(address, blockParam);

// Introspect all registered types in a code-generated service
var functionTypes = myContractService.GetAllFunctionTypes();
var eventTypes = myContractService.GetAllEventTypes();
var errorTypes = myContractService.GetAllErrorTypes();

// Get ABI metadata and Keccak signatures
var functionABIs = myContractService.GetAllFunctionABIs();
var eventABIs = myContractService.GetAllEventABIs();
var errorABIs = myContractService.GetAllErrorABIs();
var functionSigs = myContractService.GetAllFunctionSignatures();
var eventSigs = myContractService.GetAllEventsSignatures();
var errorSigs = myContractService.GetAllErrorsSignatures();

using Nethereum.Contracts.ContractStorage;

// Calculate the storage key for mapping(address => ...) at slot 0
var storageKey = StorageUtil.CalculateMappingAddressStorageKey(ownerAddress, 0);

// Read the raw storage value
var storageValue = await web3.Eth.GetStorageAt
    .SendRequestAsync(contractAddress, storageKey);