Veröffentlichen Sie Ihren ersten PoE

Das Veröffentlichen ist die Seite von Label 309, die tatsächlich ein Gateway braucht. Die Verifizierung kommt ohne Vertrauen in Dritte und ohne Konto aus; beim Veröffentlichen dagegen wird eine Transaktion on-chain (in der Blockchain) geschrieben, und das kostet eine Gebühr. Sie reichen daher über ein Label-309-Gateway ein, das die Transaktion erstellt, die Gebühr bezahlt und über sein eigenes Guthabenmodell abrechnet. SDK und CLI sind gateway-unabhängig: Richten Sie sie auf das Gateway, für das Sie einen API-Schlüssel besitzen.

Jede Veröffentlichung folgt demselben zweistufigen Ablauf: erst den Preis festschreiben, dann einreichen. Das Gateway berechnet den Preis des Datensatzes anhand eines aktuellen Wechselkurs-Snapshots und gibt eine quote_id zurück, die 15 Minuten gültig ist; der Veröffentlichungsaufruf verbraucht sie atomar zusammen mit dem Eintrag in der Blockchain. Die High-Level-Hilfsfunktionen hashen Ihren Inhalt und erstellen den kanonischen CBOR-Datensatz für Sie.

Mit dem CLI

Installieren Sie das cardanowall-Binary und richten Sie dann submit auf eine Datei. Es hasht den Inhalt, verankert den Digest und gibt das Ergebnis aus:

cardanowall submit \
  --file ./contract.pdf \
  --base-url https://your-gateway.example \
  --api-key "$CW_API_KEY"

--base-url und --api-key lesen auch aus CARDANOWALL_BASE_URL und CARDANOWALL_API_KEY oder aus einem gespeicherten Gateway-Profil, sodass sie im CI-Betrieb aus dem Befehl wegfallen können. Wenn Sie den Digest bereits besitzen, verankern Sie ihn direkt mit --hash statt --file; mit --alg blake2b-256 wechseln Sie vom Standard sha2-256, und --json liefert eine maschinenlesbare Zusammenfassung:

cardanowall submit --hash 3b9f…c1a2 --json

Um den Datensatz mit Ihrem Identitätsschlüssel zu signieren, übergeben Sie den 32-Byte-Master-Seed über --seed-file oder --seed-stdin (niemals als bloßes --seed auf der Kommandozeile, denn dort landet er in der Shell-History). Lassen Sie ihn weg, um unsigniert zu veröffentlichen.

Mit dem TypeScript-SDK

Erstellen Sie einen Client für Ihr Gateway und holen Sie dann in einem einzigen Hilfsaufruf ein Angebot ein und veröffentlichen. publishContent hasht die Bytes, erstellt den Datensatz und reicht ihn ein:

import { Label309Client } from '@cardanowall/sdk-ts';

const client = new Label309Client({
  baseUrl: 'https://your-gateway.example',
  apiKey: process.env.CW_API_KEY,
});

const quote = await client.poe.quote({
  recordBytes: 256,
  recipientCount: 0,
  fileBytesTotal: 0,
});

const result = await client.poe.publishContent({
  content: fileBytes, // Uint8Array or a UTF-8 string
  quoteId: quote.quote_id,
  // idempotencyKey: crypto.randomUUID(), // safe to retry the same submit
  // signer is optional — omit to publish unsigned (profile=core)
});

console.log(result.id, result.tx_hash, result.status);
console.log(result.balance_after_usd_micros); // decimal string of USD micro-cents

result.status beginnt bei submitting; tx_hash ist null, bis das Gateway die Transaktion erstellt hat. Übergeben Sie einen idempotencyKey, um Wiederholungsversuche abzusichern: Ein erneuter, identischer Aufruf gibt den ursprünglichen Datensatz zurück (dedup_hit: true), ohne ein zweites Mal zu belasten. Für einen vorberechneten Digest verwenden Sie publishPrehashed, für einen an Empfänger versiegelten Umschlag publishSealed.

Mit dem Python-SDK

cardanowall-sdk bildet die TypeScript-Hilfsfunktionen Methode für Methode nach. Der Client ist ein asynchroner Kontextmanager; die Antworten kommen als einfache Dicts zurück:

import asyncio
from cardanowall.client import Label309Client


async def main() -> None:
    async with Label309Client(
        base_url="https://your-gateway.example",
        api_key="<opaque-bearer>",
    ) as client:
        quote = await client.poe.quote(
            record_bytes=256, recipient_count=0, file_bytes_total=0
        )
        out = await client.poe.publish_content(
            content="hello world",  # str (UTF-8) or bytes
            quote_id=quote["quote_id"],
        )
        print(out["id"], out["tx_hash"], out["status"])


asyncio.run(main())

Mit dem Rust-SDK

Das cardanowall-Crate stellt denselben gateway-unabhängigen Client bereit. Die Aufrufe sind blockierend, es wird also keine asynchrone Laufzeitumgebung benötigt; die Hilfsfunktionen geben typisierte Ergebnisse zurück:

use cardanowall::client::{
    Label309Client, Label309ClientConfig, PublishContentInput, QuoteInput,
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Label309Client::new(Label309ClientConfig {
        base_url: Some("https://your-gateway.example".into()),
        api_key: std::env::var("CW_API_KEY").ok(),
    })?;

    let quote = client.poe().quote(&QuoteInput {
        record_bytes: 256,
        recipient_count: 0,
        file_bytes_total: 0,
    })?;

    let result = client.poe().publish_content(&PublishContentInput {
        content: file_bytes, // Vec<u8>
        quote_id: quote.quote_id,
        hash_alg: None, // defaults to sha2-256
        signer: None,   // omit to publish unsigned (profile = core)
        idempotency_key: None,
    })?;

    println!("{} {:?} {:?}", result.id, result.tx_hash, result.status);
    Ok(())
}

Für einen vorberechneten Digest verwenden Sie publish_prehashed, für einen an Empfänger versiegelten Umschlag publish_sealed.