There is no Semantic Kernel package. In Python you wrap the real blockchain0x client in a method decorated with @kernel_function; in C#, where no .NET SDK ships, a [KernelFunction] calls the REST API directly. Register it on your kernel, set FunctionChoiceBehavior to Auto, and the agent can move USDC on Base. The shipped core SDKs are Node, Python, Ruby, Go, and JVM.

Install Semantic Kernel and, in Python, the core SDK.

There is no blockchain0x Semantic Kernel package to add. Python installs Semantic Kernel plus the real blockchain0x SDK; C# installs Microsoft.SemanticKernel and calls the REST API with the built-in HttpClient. Java uses Semantic Kernel for Java plus the com.blockchain0x:sdk-jvm SDK.

pip install semantic-kernel blockchain0x

dotnet add package Microsoft.SemanticKernel

BLOCKCHAIN0X_API_KEY=sk_test_...   # sk_test_ = Base Sepolia, sk_live_ = Base mainnet
BLOCKCHAIN0X_API_KEY=sk_test_...             # same key, the name the .NET REST example reads
OPENAI_API_KEY=sk-...

BLOCKCHAIN0X_API_KEY (the Python client reads this) is a sk_test_ testnet or sk_live_ mainnet key from your dashboard; the C# REST example reads the same value from BLOCKCHAIN0X_API_KEY. OPENAI_API_KEY (or AZURE_OPENAI_* for Azure-hosted models) is your LLM key. The webhook handler additionally needs BLOCKCHAIN0X_WEBHOOK_SECRET.

ASP.NET Core minimal API for receiving payment events.

When a payment settles, Blockchain0x POSTs a signed event to your webhook URL. There is no shipped .NET verifier, so the handler verifies by hand against the documented HMAC - which is all a helper would do. .NET example below; Python and Java verify the same way with their own HMAC libraries.

using System.Security.Cryptography;
using System.Text;
using Microsoft.AspNetCore.Builder;

var app = WebApplication.CreateBuilder(args).Build();
var secret = Environment.GetEnvironmentVariable("BLOCKCHAIN0X_WEBHOOK_SECRET")!;

app.MapPost("/webhooks/payment", async (HttpRequest req) =>
{
    using var reader = new StreamReader(req.Body);
    var raw = await reader.ReadToEndAsync(); // RAW body - verify before parsing
    var sig = req.Headers["X-Blockchain0x-Signature"].ToString();
    var ts = req.Headers["X-Blockchain0x-Timestamp"].ToString();

    var parts = sig.Split(',').Select(p => p.Split('=', 2))
        .Where(p => p.Length == 2).ToDictionary(p => p[0], p => p[1]);
    var t = parts.GetValueOrDefault("t", ts);
    var v1 = parts.GetValueOrDefault("v1", sig);

    var want = Convert.ToHexString(new HMACSHA256(Encoding.UTF8.GetBytes(secret))
        .ComputeHash(Encoding.UTF8.GetBytes($"{t}.{raw}"))).ToLowerInvariant();
    var fresh = Math.Abs(DateTimeOffset.UtcNow.ToUnixTimeSeconds() - long.Parse(t)) <= 300;
    if (!fresh || !CryptographicOperations.FixedTimeEquals(
            Encoding.UTF8.GetBytes(want), Encoding.UTF8.GetBytes(v1)))
        return Results.Unauthorized();

    if (req.Headers["X-Blockchain0x-Event-Type"] == "payment.received")
        await RunFollowupAsync(); // USDC landed - do the next step
    return Results.Ok();
});

app.Run();

The algorithm is HMAC-SHA256 over the string t.rawBody, a 300-second replay window, and a constant-time compare. Read the raw body via StreamReader so the signature stays intact; do not deserialize then re-serialize. The shipped events are payment.received, payment.sent, wallet.deployed, and webhook.test. In production the webhook often runs as a separate ASP.NET Core service sharing a database with the agent so the two can coordinate.

Five Semantic Kernel-specific traps to avoid.

Semantic Kernel's plugin model is clean but has cross-language and behavior-default gotchas. Knowing them up front saves time.