ಸೆಮಾಂಟಿಕ್ ಕರ್ಣಲ್ ಪಾವತಿ ಏಕೀಕರಣ.
Semantic Kernel ಪ್ಯಾಕೇಜ್ ಅಗತ್ಯವಿಲ್ಲ. ವಾಸ್ತವ blockchain0x ಕ್ಲೈಂಟ್ ಅನ್ನು KernelFunction (Python ಅಥವಾ Java) ನಲ್ಲಿ ಸುತ್ತಿಕೊಳ್ಳಿ, ಅಥವಾ C# KernelFunction ನಿಂದ REST API ಅನ್ನು ಕರೆ ಮಾಡಿ. ಯಾವುದಾದರೂ ಮಾರ್ಗದಲ್ಲಿ ಏಜೆಂಟ್ USDC ಅನ್ನು ಬೇಸಿಗೆ ಸ್ಥಳಾಂತರಿಸುತ್ತದೆ.
Semantic Kernel ಪ್ಯಾಕೇಜ್ ಇಲ್ಲ. ಪೈಥಾನ್ನಲ್ಲಿ ನೀವು ವಾಸ್ತವ blockchain0x ಕ್ಲೈಂಟ್ ಅನ್ನು @kernel_function ಅಲಂಕರಿಸಿದ ವಿಧಾನದಲ್ಲಿ ಲುಪ್ತಗೊಳಿಸುತ್ತೀರಿ; C# ನಲ್ಲಿ, ಅಲ್ಲಿ ಯಾವುದೇ .NET SDK ಕಳುಹಿಸಲಾಗುವುದಿಲ್ಲ, [KernelFunction] ನೇರವಾಗಿ REST API ಅನ್ನು ಕರೆ ಮಾಡುತ್ತದೆ. ನಿಮ್ಮ ಕರ್ಣದಲ್ಲಿ ಇದನ್ನು ನೋಂದಾಯಿಸಿ, FunctionChoiceBehavior ಅನ್ನು Auto ಗೆ ಹೊಂದಿಸಿ, ಮತ್ತು ಏಜೆಂಟ್ USDC ಅನ್ನು Base ನಲ್ಲಿ ಚಲಾಯಿಸಬಹುದು. ಕಳುಹಿಸಲಾದ ಕೋರ್ SDK ಗಳು Node, Python, Ruby, Go, ಮತ್ತು JVM.
ಏಕೈಕ ಉದ್ಯಮ-ಮಟ್ಟದ .NET ಏಜೆಂಟ್ ಚೌಕಟ್ಟಿನ.
ನಿಮ್ಮ ಸ್ಟಾಕ್ ಮೈಕ್ರೋಸಾಫ್ಟ್-ಆಕಾರದಾದರೆ (Azure, .NET, SQL Server, ಟೀಮ್ಗಳು, ಕೋಪೈಲಟ್ ಸ್ಟುಡಿಯೋ), ಸೆಮಾಂಟಿಕ್ ಕರ್ಣಲ್ ಬಹುತೇಕ ಖಚಿತವಾಗಿ ಸರಿಯಾದ ಏಜೆಂಟ್ ಫ್ರೇಮ್ವರ್ಕ್. ಇದು ಮೈಕ್ರೋಸಾಫ್ಟ್ನಿಂದ ನಿರ್ಮಿಸಲಾಗಿದೆ, ಇದು Azure OpenAI, AKS ಮತ್ತು Entra ಅನ್ನು ಏಕೀಭೂತಗೊಳಿಸುತ್ತದೆ, ಮತ್ತು ಇದು .NET, Python ಮತ್ತು Java ನಲ್ಲಿ ಮೊದಲ-ಶ್ರೇಣಿಯ ಬೆಂಬಲವನ್ನು ಹೊಂದಿದೆ, ಇನ್ನೊಂದು ಫ್ರೇಮ್ವರ್ಕ್ ಹೊಂದಿಲ್ಲ. ಮತ್ತು ಇದು ನಿಮಗೆ ಬೇಕಾದದ್ದನ್ನು ಈಗಾಗಲೇ ನೀಡುತ್ತದೆ: KernelFunction ಕೇವಲ ಒಂದು ವಿಧಾನ, ಆದ್ದರಿಂದ ಪಾವತಿಗಳನ್ನು ಸಂಪರ್ಕಿಸುವುದು ನೀವು ಬರೆಯುವ ವಿಧಾನ, ನೀವು ಕಾಯುವ ಪ್ಯಾಕೇಜ್ ಅಲ್ಲ.
ಅದಕ್ಕಾಗಿಯೇ install ಮಾಡಲು Semantic Kernel adapter ಇಲ್ಲ. Python ಮತ್ತು Java ನಲ್ಲಿ ನೀವು real blockchain0x SDK ಅನ್ನು KernelFunction ಒಳಗೆ wrap ಮಾಡುತ್ತೀರಿ; C# ನಲ್ಲಿ, ಇನ್ನೂ ಯಾವುದೇ .NET SDK ship ಆಗಿಲ್ಲ, ಆದ್ದರಿಂದ KernelFunction HttpClient ಮೂಲಕ ನೇರವಾಗಿ REST API ಅನ್ನು call ಮಾಡುತ್ತದೆ. ನೀವು idiomatic ergonomics ಅನ್ನು ಉಳಿಸಿಕೊಳ್ಳುತ್ತೀರಿ - decorated methods, async, attribute-based parameter validation - ಮತ್ತು track ಮಾಡಲು ಯಾವುದೇ adapter version ಇಲ್ಲ. ಇಂದು ಇರುವ core SDKs ಎಂದರೆ Node, Python, Ruby, Go, ಮತ್ತು JVM.
Semantic Kernel ಅನ್ನು ಸ್ಥಾಪಿಸಿ ಮತ್ತು Python ನಲ್ಲಿ ಕೋರ್ SDK.
ಜೋಡಿಸಲು blockchain0x Semantic Kernel ಪ್ಯಾಕೇಜ್ ಇಲ್ಲ. ಪೈಥಾನ್ Semantic Kernel ಅನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ ಮತ್ತು ವಾಸ್ತವ blockchain0x SDK ಅನ್ನು; C# Microsoft.SemanticKernel ಅನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ ಮತ್ತು ನಿರ್ಮಿತ HttpClient ಅನ್ನು ಬಳಸಿಕೊಂಡು REST API ಅನ್ನು ಕರೆ ಮಾಡುತ್ತದೆ. ಜಾವಾ 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.
ಪಾವತಿ settle ಆದಾಗ, Blockchain0x ನಿಮ್ಮ webhook URL ಗೆ signed event ಅನ್ನು POST ಮಾಡುತ್ತದೆ. shipped .NET verifier ಇಲ್ಲ, ಆದ್ದರಿಂದ handler ದಾಖಲಾಗಿರುವ HMAC ವಿರುದ್ಧ ಕೈಯಾರೆ verify ಮಾಡುತ್ತದೆ - helper ಮಾಡುವುದೂ ಅದೇ. ಕೆಳಗೆ .NET example ಇದೆ; Python ಮತ್ತು Java ತಮ್ಮದೇ HMAC libraries ಬಳಸಿ ಅದೇ ರೀತಿಯಲ್ಲಿ verify ಮಾಡುತ್ತವೆ.
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();algorithm ಎಂದರೆ t.rawBody string ಮೇಲೆ HMAC-SHA256, 300-second replay window, ಮತ್ತು constant-time compare. signature intact ಆಗಿರಲು raw body ಅನ್ನು StreamReader ಮೂಲಕ read ಮಾಡಿ; deserialize ಮಾಡಿ ಮತ್ತೆ re-serialize ಮಾಡಬೇಡಿ. ship ಮಾಡಲಾದ events payment.received, payment.sent, wallet.deployed, ಮತ್ತು webhook.test. production ನಲ್ಲಿ webhook ಬಹುಶಃ agent ಜೊತೆಗೆ database share ಮಾಡುವ separate ASP.NET Core service ಆಗಿ run ಆಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಎರಡೂ coordinate ಮಾಡಬಹುದು.
SDKs ಮತ್ತು REST surface open ಆಗಿವೆ. ಅವನ್ನು read ಮಾಡಿ.
ಕ್ಲೋನ್ ಮಾಡಲು ಯಾವುದೇ Semantic Kernel starter package ಇಲ್ಲ - ಮೇಲಿನ recipes ಗಳು integration ಆಗಿವೆ. blockchain0x core SDKs (Node, Python, Ruby, Go) GitHub ನಲ್ಲಿ open source ಆಗಿವೆ, ಮತ್ತು ಅವುಗಳ method surface ಜೊತೆಗೆ C# example ಕರೆಯುವ REST routes ಗಳು docs ನಲ್ಲಿ ದಾಖಲಿಸಲಾಗಿದೆ.
docs.blockchain0x.com/docs/overviewSDK method surface ಮತ್ತು REST routes ಗಳು the docs ನಲ್ಲಿ documented ಆಗಿವೆ. Base Sepolia ವಿರುದ್ಧ sk_test_ key ನಿಂದ ಆರಂಭಿಸಿ, ನಂತರ KernelFunction ನೀವು ನಿರೀಕ್ಷಿಸುವಂತೆ ಕೆಲಸ ಮಾಡಿದಾಗ sk_live_ ಗೆ switch ಮಾಡಿ.
ಐದು ಸೆಮಾಂಟಿಕ್ ಕರ್ಣಲ್-ನಿರ್ದಿಷ್ಟ ಬಲೆಗೆಗಳನ್ನು ತಪ್ಪಿಸಲು.
ಸೆಮಾಂಟಿಕ್ ಕರ್ಣಲ್ನ ಪ್ಲಗಿನ್ ಮಾದರಿ ಸ್ವಚ್ಛವಾಗಿದೆ ಆದರೆ ಭಾಷಾಂತರ ಮತ್ತು ವರ್ತನೆ-ಡೀಫಾಲ್ಟ್ ಸಮಸ್ಯೆಗಳಿವೆ. ಅವುಗಳನ್ನು ಮುಂಚೆ ತಿಳಿದಿರುವುದು ಸಮಯವನ್ನು ಉಳಿಸುತ್ತದೆ.
ಯಾವುದೇ ಭಾಷೆಯಲ್ಲಿ Semantic Kernel ಪ್ಯಾಕೇಜ್ ಇಲ್ಲ
NuGet, PyPI, ಅಥವಾ Maven ಅಡಾಪ್ಟರ್ ಇಲ್ಲ. ಕಳುಹಿಸಲಾದ ಕೋರ್ SDK ಗಳು Node, Python, Ruby, Go, ಮತ್ತು JVM - .NET ಅಲ್ಲ. ಆದ್ದರಿಂದ ಪೈಥಾನ್ ಕರ್ಣವು blockchain0x ಪೈಥಾನ್ ಕ್ಲೈಂಟ್ ಅನ್ನು @kernel_function ನಲ್ಲಿ ಲುಪ್ತಗೊಳಿಸುತ್ತದೆ, ಜಾವಾ ಕರ್ಣವು com.blockchain0x:sdk-jvm SDK ಅನ್ನು ಬಳಸುತ್ತದೆ, ಮತ್ತು C# ಕರ್ಣವು KernelFunction (ಮೇಲಿನಂತೆ ತೋರಿಸಲಾಗಿದೆ) ನಿಂದ ನೇರವಾಗಿ REST API ಅನ್ನು ಕರೆ ಮಾಡುತ್ತದೆ. ಎಲ್ಲಾ ಮೂರು ಕೆಲವು ಸಾಲುಗಳಾಗಿವೆ.
FunctionChoiceBehavior ಸ್ವಾಯತ್ತವಾಗಿರಬೇಕು
Semantic Kernel plugin ಕಾರ್ಯಗಳನ್ನು ಮಾತ್ರ FunctionChoiceBehavior ಅನ್ನು ಪ್ರಾಂಪ್ಟ್-ನಿರ್ವಹಣಾ ಸೆಟ್ಟಿಂಗ್ಗಳಲ್ಲಿ Auto ಗೆ ಹೊಂದಿಸಿದಾಗ ಕರೆ ಮಾಡುತ್ತದೆ. ಡೀಫಾಲ್ಟ್ None ಆಗಿದೆ, ಆದ್ದರಿಂದ ಬಳಕೆದಾರನು ಹೇಗೆ ಸ್ಪಷ್ಟವಾಗಿ ಕೇಳಿದರೂ ಮಾದರಿ ನಿಮ್ಮ ವಾಲೆಟ್ ಕಾರ್ಯವನ್ನು ಕರೆ ಮಾಡುವುದಿಲ್ಲ. ಏಜೆಂಟ್ ಸಂಪೂರ್ಣವಾಗಿ ಕಾರ್ಯವನ್ನು ನಿರ್ಲಕ್ಷಿಸಿದರೆ, ಇದನ್ನು ಮೊದಲು ಪರಿಶೀಲಿಸಿ.
ಮೌಲ್ಯಗಳು USDC ಆಧಾರ ಘಟಕಗಳಾಗಿವೆ, ಸ್ಟ್ರಿಂಗ್ಗಳಂತೆ
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.
ಏಜೆಂಟ್ಗಳ ನಡುವೆ ಪ್ಲಗಿನ್ ವ್ಯಾಪ್ತಿ
ಖರ್ಚು ಅಧಿಕಾರವನ್ನು ಹೊಂದಬೇಕಾದ ಏಜೆಂಟ್ನ ಕರ್ಣಲ್ನಲ್ಲಿ ಮಾತ್ರ ವಾಲೆಟ್ ಕಾರ್ಯವನ್ನು ನೋಂದಾಯಿಸಿ. ಪ್ಲಗಿನ್ ಜಾಗತಿಕವಲ್ಲ - ಇದರ ಕರ್ಣಲ್ ಇಲ್ಲದ ಏಜೆಂಟ್ ಅದನ್ನು ಕರೆ ಮಾಡಲಾಗುವುದಿಲ್ಲ. ವಿಮರ್ಶಕರ ಏಜೆಂಟ್ಗೆ ವಾಲೆಟ್ ಕಾರ್ಯವಿಲ್ಲದ ಕರ್ಣಲ್ ನೀಡಿ, ಅಥವಾ ಪ್ರತಿ ಏಜೆಂಟ್ಗೆ ಅನುಮತಿಸಲಾದ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ಬಂಧಿಸಿ, ಆದ್ದರಿಂದ ಹಣ ಒಂದು ಪಾತ್ರದಲ್ಲಿಯೇ ಉಳಿಯುತ್ತದೆ.
Webhooks ಅನ್ನು raw body ವಿರುದ್ಧ verify ಮಾಡಿ
ಕಚ್ಚಾ ವಿನಂತಿಯ ಶರೀರವನ್ನು ಓದಿ ಮತ್ತು ಡಿಸೀರಿಯಲೈಜ್ ಮಾಡುವ ಮೊದಲು ಪರಿಶೀಲಿಸಿ - HMAC ನಿಖರವಾದ ಬೈಟ್ಗಳನ್ನು ಆವರಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಪಾರ್ಸ್-ಮರುಸೇರಿಸುವ ಸುತ್ತು ಅದನ್ನು ಒಡೆದು ಹಾಕುತ್ತದೆ. ಕೆಳಗಿನ .NET ಹ್ಯಾಂಡ್ಲರ್ ದಾಖಲೆಗೊಳಿಸಿದ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸುತ್ತದೆ: HMAC-SHA256 t.rawBody, 300-ಸೆಕೆಂಡು ಕಿಟಕಿಯ ಮೇಲೆ, ಮತ್ತು ನಿರಂತರ-ಕಾಲದ ಹೋಲಿಸುವಿಕೆ. Python ಮತ್ತು Java ತಮ್ಮದೇ ಆದ HMAC ಗ್ರಂಥಾಲಯಗಳೊಂದಿಗೆ ಒಂದೇ ರೀತಿಯಲ್ಲಿ ಪರಿಶೀಲಿಸುತ್ತವೆ.