సెమాంటిక్ కర్నల్ చెల్లింపు ఇంటిగ్రేషన్.
Semantic Kernel ప్యాకేజీ అవసరం లేదు. నిజమైన blockchain0x క్లయింట్ను KernelFunction (Python లేదా Java) లో చుట్టండి, లేదా C# KernelFunction నుండి REST APIని కాల్ చేయండి. ఏదైనా మార్గంలో ఏజెంట్ USDCని Base పై కదులుతుంది.
Semantic Kernel ప్యాకేజీ లేదు. Pythonలో మీరు వాస్తవ blockchain0x క్లయింట్ను @kernel_functionతో అలంకరించిన పద్ధతిలో చుట్టుతారు; C#లో, ఎక్కడా .NET SDK పంపబడదు, [KernelFunction] నేరుగా REST APIని కాల్ చేస్తుంది. మీ కర్నల్లో దానిని నమోదు చేయండి, FunctionChoiceBehaviorని ఆటోగా సెట్ చేయండి, మరియు ఏజెంట్ Baseలో USDCని కదిలించగలదు. పంపిన కోర్ SDKలు Node, Python, Ruby, Go, మరియు JVM.
ఒకే ఎంటర్ప్రైజ్-గ్రేడ్ .NET ఏజెంట్ ఫ్రేమ్వర్క్.
మీ స్టాక్ Microsoft ఆకారంలో ఉంటే (Azure, .NET, SQL Server, Teams, Copilot Studio), Semantic Kernel అనేది సరిగ్గా సరైన ఏజెంట్ ఫ్రేమ్వర్క్. ఇది Microsoft ద్వారా నిర్మించబడింది, ఇది Azure OpenAI, AKS మరియు Entra తో సమీకరించబడింది, మరియు ఇది ఇతర ఫ్రేమ్వర్క్లతో సరిపోలని విధంగా .NET, Python మరియు Javaలో మొదటి-తరగతి మద్దతును కలిగి ఉంది. మరియు ఇది మీకు అవసరమైనది: KernelFunction కేవలం ఒక పద్ధతి, కాబట్టి చెల్లింపులను కేబుల్ చేయడం మీరు రాస్తున్న పద్ధతి, మీరు వేచి ఉండే ప్యాకేజీ కాదు.
అది ఎందుకంటే ఇన్స్టాల్ చేయడానికి ఎలాంటి సెమాంటిక్ కర్నల్ అడాప్టర్ లేదు. Python మరియు Javaలో మీరు నిజమైన blockchain0x SDKని KernelFunction లో ముడివేస్తారు; C#లో, ఎక్కడా .NET SDK ఇంకా రాకపోతే, KernelFunction REST APIని HttpClient తో నేరుగా కాల్ చేస్తుంది. మీరు భాషా ప్రకారం ఎర్గోనామిక్స్ను ఉంచుతారు - అలంకరించిన పద్ధతులు, అసింక్, అట్రిబ్యూట్ ఆధారిత పారామీటర్ ధృవీకరణ - మరియు ట్రాక్ చేయడానికి ఎలాంటి అడాప్టర్ సంస్కరణ లేదు. ఈ రోజు ఉన్న కోర్ SDKలు Node, Python, Ruby, Go మరియు JVM.
Semantic Kernelని ఇన్స్టాల్ చేయండి మరియు, Pythonలో, కోర్ SDKని.
చేర్చడానికి blockchain0x Semantic Kernel ప్యాకేజీ లేదు. Python Semantic Kernelని ఇన్స్టాల్ చేస్తుంది మరియు నిజమైన blockchain0x SDKని; C# Microsoft.SemanticKernelని ఇన్స్టాల్ చేస్తుంది మరియు బిల్ట్-ఇన్ HttpClientతో REST APIని కాల్ చేస్తుంది. Java Java కోసం Semantic Kernelని com.blockchain0x:sdk-jvm SDKతో ఉపయోగిస్తుంది.
pip install semantic-kernel blockchain0xdotnet add package Microsoft.SemanticKernelBLOCKCHAIN0X_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 (Python client దీన్ని చదువుతుంది) అనేది మీ dashboard లోని sk_test_ testnet లేదా sk_live_ mainnet key; C# REST ఉదాహరణ అదే విలువను BLOCKCHAIN0X_API_KEY నుండి చదువుతుంది. OPENAI_API_KEY (లేదా Azure-hosted models కోసం AZURE_OPENAI_*) మీ LLM key. webhook handler కు అదనంగా BLOCKCHAIN0X_WEBHOOK_SECRET అవసరం.
ఒక వాలెట్ KernelFunction, Python మరియు C#లో.
Python నిజమైన blockchain0x క్లయింట్ను @kernel_function తో అలంకరించిన పద్ధతిలో చుట్టిస్తుంది. C#, ఎక్కడ .NET SDK పంపబడదు, HttpClient తో నేరుగా POST /v1/payments ను కాల్ చేసే [KernelFunction] ను ప్రదర్శిస్తుంది. రెండూ కర్నల్లో Wallet.send_usdc గా నమోదు చేస్తాయి; చుట్టుపక్కల వేడుక మాత్రమే భిన్నంగా ఉంటుంది.
from semantic_kernel import Kernel from semantic_kernel.functions import kernel_function from blockchain0x import Client blockchain0x = Client() # reads BLOCKCHAIN0X_API_KEY from the environment class WalletPlugin: @kernel_function(description="Send a USDC payment from an agent wallet.") def send_usdc(self, agent_id: str, to: str, amount_wei: str) -> str: # amount_wei is USDC base units (6 decimals): "10000" = 0.01 USDC return str( blockchain0x.payments.create(body={"agentId": agent_id, "to": to, "amountWei": amount_wei}) ) kernel = Kernel() kernel.add_plugin(WalletPlugin(), plugin_name="Wallet") # Add your chat service, then let the model call Wallet.send_usdc.
using System.ComponentModel;
using System.Net.Http.Json;
using Microsoft.SemanticKernel;
// There is no .NET SDK, so a C# KernelFunction calls the REST API directly.
public class WalletPlugin
{
private static readonly HttpClient Http = new()
{
BaseAddress = new Uri("https://api.blockchain0x.com"),
};
[KernelFunction, Description("Send a USDC payment from an agent wallet. amountWei is USDC base units (6 decimals).")]
public async Task<string> SendUsdc(string agentId, string to, string amountWei)
{
Http.DefaultRequestHeaders.Authorization =
new("Bearer", Environment.GetEnvironmentVariable("BLOCKCHAIN0X_API_KEY"));
var res = await Http.PostAsJsonAsync("/v1/payments", new { agentId, to, amountWei });
return await res.Content.ReadAsStringAsync();
}
}
// builder.Plugins.AddFromType<WalletPlugin>("Wallet");Register the function on the kernel, set FunctionChoiceBehavior to Auto, and when the user's message implies a payment the model calls Wallet.send_usdc with the agent id, recipient, and amount. amountWei is base units, so 0.01 USDC is "10000". The Python path returns the SDK result; the C# path returns the REST response body.
చెల్లింపు ఈవెంట్స్ను స్వీకరించడానికి ASP.NET కోర్ కనిష్ట API.
ఒక చెల్లింపు స్థిరమైనప్పుడు, Blockchain0x మీ వెబ్హుక్ URL కు సంతకం చేసిన ఈవెంట్ను POST చేస్తుంది. పంపించిన .NET ధృవీకర్త లేదు, కాబట్టి హ్యాండ్లర్ డాక్యుమెంటెడ్ HMAC కు చేతితో ధృవీకరించుతుంది - ఇది సహాయానికి ఏదీ చేయదు. క్రింద .NET ఉదాహరణ; Python మరియు Java తమ HMAC లైబ్రరీలతో అదే విధంగా ధృవీకరిస్తాయి.
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();అల్గోరిథం t.rawBody అనే స్ట్రింగ్పై HMAC-SHA256, 300-సెకన్ల రీప్లే విండో, మరియు స్థిర-సమయాన్ని పోల్చడం. సంతకం intact గా ఉండటానికి స్ట్రీమ్రీడర్ ద్వారా కచ్చితమైన శరీరాన్ని చదవండి; డీసీరియలైజ్ చేసి మళ్లీ సీరియలైజ్ చేయకండి. పంపిన ఈవెంట్లు payment.received, payment.sent, wallet.deployed, మరియు webhook.test. ఉత్పత్తిలో వెబ్హుక్ తరచుగా ఏజెంట్తో డేటాబేస్ను పంచుకునే వేరే ASP.NET కోర్ సేవగా నడుస్తుంది కాబట్టి వీరు సమన్వయించవచ్చు.
SDKలు మరియు REST ఉపరితలాలు ఓపెన్ ఉన్నాయి. వాటిని చదవండి.
clone చేయడానికి ప్రత్యేక Semantic Kernel starter package లేదు - పై recipes నే integration. blockchain0x core SDKs (Node, Python, Ruby, Go) GitHub లో open source గా ఉన్నాయి, మరియు వాటి method surface తో పాటు C# example call చేసే REST routes కూడా docs లో documented ఉన్నాయి.
docs.blockchain0x.com/docs/overviewSDK method surface మరియు REST routes the docs లో documented గా ఉన్నాయి. Base Sepolia పై sk_test_ key తో start చేయండి, తర్వాత KernelFunction మీరు ఆశించినట్లు పనిచేసినప్పుడు sk_live_ కి switch చేయండి.
గమనించాల్సిన ఐదు Semantic Kernel-సంబంధిత చిక్కులు.
సెమాంటిక్ కర్నల్ యొక్క ప్లగిన్ మోడల్ క్లియర్ కానీ క్రాస్-భాష మరియు ప్రవర్తన-డిఫాల్ట్ గాట్చాస్ ఉన్నాయి. వాటిని ముందుగా తెలుసుకోవడం సమయాన్ని ఆదా చేస్తుంది.
ఏ భాషలోనైనా Semantic Kernel ప్యాకేజీ లేదు
NuGet, PyPI, లేదా Maven అడాప్టర్ లేదు. పంపిన కోర్ SDKలు Node, Python, Ruby, Go, మరియు JVM - .NET కాదు. కాబట్టి ఒక Python కర్నల్ blockchain0x Python క్లయింట్ను @kernel_functionలో చుట్టుతుంది, ఒక Java కర్నల్ com.blockchain0x:sdk-jvm SDKని ఉపయోగిస్తుంది, మరియు ఒక C# కర్నల్ KernelFunction నుండి నేరుగా REST APIని కాల్ చేస్తుంది (పై చూపబడింది). ఈ మూడు కొన్ని పంక్తులు.
FunctionChoiceBehavior ఆటోగా ఉండాలి
సెమాంటిక్ కర్నల్ ఫంక్షన్చాయిస్బిహేవియర్ ప్రాంప్ట్-అమలు సెట్టింగ్స్లో ఆటోగా సెట్ చేయబడినప్పుడు మాత్రమే ప్లగిన్ ఫంక్షన్లను పిలుస్తుంది. డిఫాల్ట్ None, కాబట్టి వినియోగదారు ఎంత స్పష్టంగా అడిగినా మోడల్ మీ వాలెట్ ఫంక్షన్ను కాల్ చేయదు. ఏజెంట్ ఫంక్షన్ను పూర్తిగా నిర్లక్ష్యం చేస్తే, ముందుగా దీన్ని తనిఖీ చేయండి.
Amounts USDC base units గా, strings రూపంలో
The payments call takes amountWei: a string of USDC base units (6 decimals), so 0.01 USDC is "10000" and 5 USDC is "5000000". Type the function argument as a string in any language. payments.create also does not retry by default and can answer 503 until the chain adapter is wired for your network - return a clear message rather than letting the agent loop.
ఏజెంట్ల మధ్య ప్లగిన్ పరిధి
ఖర్చు అధికారం కలిగి ఉండాల్సిన ఏజెంట్ యొక్క కర్నల్పై మాత్రమే వాలెట్ ఫంక్షన్ను నమోదు చేయండి. ప్లగిన్ ప్రపంచవ్యాప్తం కాదు - దానిలో కర్నల్ లేని ఏజెంట్ దాన్ని కాల్ చేయలేరు. సమీక్షకుడికి వాలెట్ ఫంక్షన్ లేకుండా కర్నల్ ఇవ్వండి, లేదా ప్రతి ఏజెంట్కు అనుమతించిన ఫంక్షన్లను పరిమితం చేయండి, కాబట్టి డబ్బు ఒక పాత్రలోనే ఉంటుంది.
వెబ్హుక్లను కచ్చితమైన శరీరానికి ధృవీకరించండి
కచ్చితమైన అభ్యర్థన శరీరాన్ని చదవండి మరియు డీసీరియలైజ్ చేయడానికి ముందు ధృవీకరించండి - HMAC ఖచ్చితమైన బైట్స్ను కవర్ చేస్తుంది, కాబట్టి ఒక పార్స్-తర్వాత-రీసీరియలైజ్ రౌండ్ ట్రిప్ దాన్ని పగులగొడుతుంది. క్రింద ఉన్న .NET హ్యాండ్లర్ డాక్యుమెంటెడ్ అల్గోరిథమ్ను అమలు చేస్తుంది: t.rawBody పై HMAC-SHA256, 300-సెకన్ల విండో, మరియు స్థిర-సమయ పోల్చడం. Python మరియు Java తమ HMAC లైబ్రరీలతో అదే విధంగా ధృవీకరిస్తాయి.