ਸੇਮਾਂਟਿਕ ਕਰਨਲ ਭੁਗਤਾਨ ਇਕੀਕਰਨ।
ਕੋਈ Semantic Kernel ਪੈਕੇਜ ਦੀ ਲੋੜ ਨਹੀਂ। ਅਸਲ blockchain0x ਕਲਾਇੰਟ ਨੂੰ ਇੱਕ KernelFunction (Python ਜਾਂ Java) ਵਿੱਚ ਲਪੇਟੋ, ਜਾਂ C# KernelFunction ਤੋਂ REST API ਨੂੰ ਕਾਲ ਕਰੋ। ਕਿਸੇ ਵੀ ਤਰੀਕੇ ਨਾਲ ਏਜੰਟ USDC ਨੂੰ Base 'ਤੇ ਚਲਾਉਂਦਾ ਹੈ।
ਕੋਈ Semantic Kernel ਪੈਕੇਜ ਨਹੀਂ ਹੈ। Python ਵਿੱਚ ਤੁਸੀਂ ਅਸਲੀ blockchain0x ਕਲਾਇੰਟ ਨੂੰ @kernel_function ਨਾਲ ਸਜਾਏ ਗਏ ਇੱਕ ਵਿਧੀ ਵਿੱਚ ਲਪੇਟਦੇ ਹੋ; C# ਵਿੱਚ, ਜਿੱਥੇ ਕੋਈ .NET ਐਸਡੀਕੇ ਭੇਜਿਆ ਨਹੀਂ ਜਾਂਦਾ, ਇੱਕ [KernelFunction] ਸਿੱਧਾ REST API ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ। ਇਸਨੂੰ ਆਪਣੇ ਕਿਰਨ 'ਤੇ ਰਜਿਸਟਰ ਕਰੋ, FunctionChoiceBehavior ਨੂੰ Auto 'ਤੇ ਸੈਟ ਕਰੋ, ਅਤੇ ਏਜੰਟ USDC ਨੂੰ ਬੇਸ 'ਤੇ ਚਲਾ ਸਕਦਾ ਹੈ। ਭੇਜੇ ਗਏ ਕੋਰ ਐਸਡੀਕੇ Node, Python, Ruby, Go, ਅਤੇ JVM ਹਨ।
ਇੱਕੋ ਹੀ ਉਦਯੋਗ-ਗ੍ਰੇਡ .NET ਏਜੰਟ ਫਰੇਮਵਰਕ।
ਜੇ ਤੁਹਾਡਾ ਸਟੈਕ ਮਾਈਕਰੋਸਾਫਟ-ਆਕਾਰ ਦਾ ਹੈ (Azure, .NET, SQL Server, Teams, Copilot Studio), ਤਾਂ Semantic Kernel ਬੇਸ਼ੱਕ ਸਹੀ ਏਜੰਟ ਫਰੇਮਵਰਕ ਹੈ। ਇਹ ਮਾਈਕਰੋਸਾਫਟ ਦੁਆਰਾ ਬਣਾਇਆ ਗਿਆ ਹੈ, ਇਹ Azure OpenAI, AKS, ਅਤੇ Entra ਨਾਲ ਇੰਟੀਗ੍ਰੇਟ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਇਹ .NET, Python, ਅਤੇ Java ਵਿੱਚ ਪਹਿਲੀ ਕਲਾਸ ਦਾ ਸਮਰਥਨ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜਿਸ ਤਰੀਕੇ ਨਾਲ ਕੋਈ ਹੋਰ ਫਰੇਮਵਰਕ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ। ਅਤੇ ਇਹ ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਹੀ ਉਹ ਚੀਜ਼ ਦਿੰਦਾ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਚਾਹੀਦੀ ਹੈ: ਇੱਕ KernelFunction ਸਿਰਫ ਇੱਕ ਵਿਧੀ ਹੈ, ਇਸ ਲਈ ਭੁਗਤਾਨਾਂ ਨੂੰ ਵਾਇਰਿੰਗ ਕਰਨਾ ਇੱਕ ਵਿਧੀ ਹੈ ਜੋ ਤੁਸੀਂ ਲਿਖਦੇ ਹੋ, ਨਾ ਕਿ ਇੱਕ ਪੈਕੇਜ ਜਿਸ ਦੀ ਤੁਸੀਂ ਉਡੀਕ ਕਰਦੇ ਹੋ।
ਇਸੇ ਲਈ install ਕਰਨ ਲਈ ਕੋਈ Semantic Kernel adapter ਨਹੀਂ ਹੈ। Python ਅਤੇ Java ਵਿੱਚ ਤੁਸੀਂ real blockchain0x SDK ਨੂੰ KernelFunction ਵਿੱਚ wrap ਕਰਦੇ ਹੋ; C# ਵਿੱਚ, ਜਿੱਥੇ ਹਾਲੇ ਕੋਈ .NET SDK ships ਨਹੀਂ ਕਰਦਾ, 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 ਪੈਕੇਜ ਨਹੀਂ ਹੈ ਜੋ ਜੋੜਿਆ ਜਾ ਸਕੇ। Python Semantic Kernel ਨੂੰ ਇੰਸਟਾਲ ਕਰਦਾ ਹੈ ਅਤੇ ਅਸਲੀ blockchain0x SDK; C# Microsoft.SemanticKernel ਨੂੰ ਇੰਸਟਾਲ ਕਰਦਾ ਹੈ ਅਤੇ ਬਣੇ ਹੋਏ HttpClient ਨਾਲ REST API ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ। Java Semantic Kernel for Java ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਅਤੇ 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 example ਉਹੀ value 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 ਨਹੀਂ ਆਉਂਦਾ, ਇੱਕ [KernelFunction] ਨੂੰ ਪ੍ਰਗਟ ਕਰਦਾ ਹੈ ਜੋ POST /v1/payments ਨੂੰ HttpClient ਨਾਲ ਸਿੱਧਾ ਕਾਲ ਕਰਦਾ ਹੈ। ਦੋਹਾਂ ਨੂੰ ਵੈਲਟ.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।
ਜਦੋਂ payment settle ਹੁੰਦੀ ਹੈ, Blockchain0x ਤੁਹਾਡੇ webhook URL 'ਤੇ ਇੱਕ signed event POST ਕਰਦਾ ਹੈ। ਕੋਈ shipped .NET verifier ਨਹੀਂ ਹੈ, ਇਸ ਲਈ handler documented HMAC ਦੇ ਖਿਲਾਫ ਖੁਦ verify ਕਰਦਾ ਹੈ - ਜੋ helper ਵੀ ਕਰਦਾ। ਹੇਠਾਂ .NET example ਹੈ; Python ਅਤੇ Java ਆਪਣੇ 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();Algorithm t.rawBody string ਉੱਤੇ HMAC-SHA256, 300-second replay window, ਅਤੇ constant-time compare ਹੈ। Raw body ਨੂੰ StreamReader ਰਾਹੀਂ ਪੜ੍ਹੋ ਤਾਂ ਜੋ signature intact ਰਹੇ; deserialize ਕਰਕੇ ਫਿਰ re-serialize ਨਾ ਕਰੋ। Shipped events ਹਨ payment.received, payment.sent, wallet.deployed, ਅਤੇ webhook.test। Production ਵਿੱਚ webhook ਅਕਸਰ ਇੱਕ ਵੱਖਰੀ ASP.NET Core service ਵਜੋਂ ਚਲਦਾ ਹੈ ਜੋ agent ਨਾਲ ਇੱਕ database share ਕਰਦੀ ਹੈ ਤਾਂ ਜੋ ਦੋਵੇਂ coordinate ਕਰ ਸਕਣ।
SDKs ਅਤੇ REST surface open ਹਨ। ਉਨ੍ਹਾਂ ਨੂੰ ਪੜ੍ਹੋ।
ਕੋਈ Semantic Kernel starter package ਨਹੀਂ ਹੈ ਜਿਸਨੂੰ clone ਕੀਤਾ ਜਾ ਸਕੇ - ਉੱਪਰ ਦਿੱਤੇ recipes ਹੀ integration ਹਨ। blockchain0x core SDKs (Node, Python, Ruby, Go) GitHub 'ਤੇ open source ਹਨ, ਅਤੇ ਉਨ੍ਹਾਂ ਦੀ method surface ਨਾਲ ਨਾਲ ਉਹ REST routes ਜਿਨ੍ਹਾਂ ਨੂੰ C# example call ਕਰਦਾ ਹੈ, docs ਵਿੱਚ ਦਰਜ ਹਨ।
docs.blockchain0x.com/docs/overviewSDK method surface ਅਤੇ REST routes the docs 'ਤੇ documented ਹਨ। Base Sepolia ਦੇ ਖ਼ਿਲਾਫ਼ sk_test_ key ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ, ਫਿਰ ਜਦੋਂ KernelFunction ਤੁਹਾਡੀ ਉਮੀਦ ਅਨੁਸਾਰ ਕੰਮ ਕਰੇ, sk_live_ 'ਤੇ switch ਕਰੋ।
ਪੰਜ Semantic Kernel-ਵਿਸ਼ੇਸ਼ ਜਾਲਾਂ ਤੋਂ ਬਚਣ ਲਈ।
ਸੇਮਾਂਟਿਕ ਕਰਨਲ ਦਾ ਪਲੱਗਇਨ ਮਾਡਲ ਸਾਫ਼ ਹੈ ਪਰ ਇਸ ਵਿੱਚ ਭਾਸ਼ਾ-ਵਿਆਪਕ ਅਤੇ ਵਿਵਹਾਰ-ਡਿਫਾਲਟ ਸਮੱਸਿਆਵਾਂ ਹਨ। ਇਨ੍ਹਾਂ ਨੂੰ ਪਹਿਲਾਂ ਜਾਣਨਾ ਸਮਾਂ ਬਚਾਉਂਦਾ ਹੈ।
ਕੋਈ Semantic Kernel ਪੈਕੇਜ ਨਹੀਂ ਹੈ, ਕਿਸੇ ਵੀ ਭਾਸ਼ਾ ਵਿੱਚ
ਕੋਈ NuGet, PyPI, ਜਾਂ Maven ਐਡਾਪਟਰ ਨਹੀਂ ਹੈ। ਭੇਜੇ ਗਏ ਕੋਰ ਐਸਡੀਕੇ Node, Python, Ruby, Go, ਅਤੇ JVM ਹਨ - .NET ਨਹੀਂ। ਇਸ ਲਈ ਇੱਕ Python ਕਿਰਨ blockchain0x Python ਕਲਾਇੰਟ ਨੂੰ @kernel_function ਵਿੱਚ ਲਪੇਟਦਾ ਹੈ, ਇੱਕ Java ਕਿਰਨ com.blockchain0x:sdk-jvm ਐਸਡੀਕੇ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਇੱਕ C# ਕਿਰਨ KernelFunction ਤੋਂ ਸਿੱਧਾ REST API ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ (ਉਪਰ ਦਿਖਾਇਆ ਗਿਆ)। ਤਿੰਨੋਂ ਕੁਝ ਲਾਈਨਾਂ ਹਨ।
FunctionChoiceBehavior ਨੂੰ Auto ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ
Semantic Kernel ਸਿਰਫ ਉਸ ਵੇਲੇ ਪਲੱਗਇਨ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ ਜਦੋਂ 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.
ਏਜੰਟਾਂ ਵਿੱਚ ਪਲੱਗਇਨ ਦਾ ਦਾਇਰਾ
ਵਾਲਿਟ ਫੰਕਸ਼ਨ ਨੂੰ ਸਿਰਫ ਉਸ ਏਜੰਟ ਦੇ ਕਰਨਲ 'ਤੇ ਰਜਿਸਟਰ ਕਰੋ ਜੋ ਖਰਚ ਕਰਨ ਦੀ ਅਧਿਕਾਰ ਰੱਖਦਾ ਹੈ। ਪਲੱਗਇਨ ਗਲੋਬਲ ਨਹੀਂ ਹੈ - ਇੱਕ ਏਜੰਟ ਜਿਸਦਾ ਕਰਨਲ ਇਸਨੂੰ ਨਹੀਂ ਰੱਖਦਾ ਉਹ ਇਸਨੂੰ ਕਾਲ ਨਹੀਂ ਕਰ ਸਕਦਾ। ਇੱਕ ਸਮੀਖਕ ਏਜੰਟ ਨੂੰ ਵਾਲਿਟ ਫੰਕਸ਼ਨ ਤੋਂ ਬਿਨਾਂ ਇੱਕ ਕਰਨਲ ਦਿਓ, ਜਾਂ ਪ੍ਰਤੀ ਏਜੰਟ ਦੀ ਆਗਿਆਤ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸੀਮਿਤ ਕਰੋ, ਤਾਂ ਜੋ ਪੈਸਾ ਇੱਕ ਭੂਮਿਕਾ ਵਿੱਚ ਰਹੇ।
ਵੈਬਹੂਕ ਨੂੰ ਕੱਚੇ ਸਰੀਰ ਦੇ ਖਿਲਾਫ ਪੁਸ਼ਟੀ ਕਰੋ
ਕੱਚੇ ਬੇਨਤੀ ਦੇ ਬਾਡੀ ਨੂੰ ਪੜ੍ਹੋ ਅਤੇ ਡੀਸਿਰੀਅਲਾਈਜ਼ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਵੈਰੀਫਾਈ ਕਰੋ - HMAC ਸਹੀ ਬਾਈਟਾਂ ਨੂੰ ਕਵਰ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਇੱਕ ਪਾਰਸ-ਤਦ-ਰੀਸਿਰੀਅਲਾਈਜ਼ ਰਾਊਂਡ ਟ੍ਰਿਪ ਇਸਨੂੰ ਤੋੜ ਦਿੰਦੀ ਹੈ। ਹੇਠਾਂ ਦਿੱਤਾ ਗਿਆ .NET ਹੈਂਡਲਰ ਦਸਤਾਵੇਜ਼ਿਤ ਅਲਗੋਰਿਦਮ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ: HMAC-SHA256 t.rawBody 'ਤੇ, 300-ਸਕਿੰਟ ਦੀ ਖਿੜਕੀ, ਅਤੇ ਇੱਕ ਸਥਾਈ-ਸਮਾਂ ਤੁਲਨਾ। Python ਅਤੇ Java ਆਪਣੇ HMAC ਲਾਇਬ੍ਰੇਰੀਆਂ ਨਾਲ ਇੱਕੋ ਤਰ੍ਹਾਂ ਵੈਰੀਫਾਈ ਕਰਦੇ ਹਨ।