Vérifier un enregistrement

La vérification est la moitié de Label 309 qui ne demande la permission de personne. À partir d’une référence de transaction Cardano, vous pouvez confirmer un enregistrement vous-même, face à la chaîne publique et au moyen d’un explorateur que vous choisissez. Il n’y a aucune connexion, et rien dans le résultat ne dépend de celui qui l’a publié.

Avec la CLI

Installez le binaire cardanowall, puis pointez-le vers une transaction :

cardanowall verify 3b9f…c1a2

Il résout la transaction via un explorateur Cardano public, valide structurellement l’enregistrement, contrôle les éventuelles signatures de paternité, confirme que l’enregistrement est définitivement consolidé et affiche un verdict. Le verdict est l’un des quatre états, et le code de sortie le transmet tel quel, de sorte qu’il s’intègre directement dans la CI :

La distinction entre failed et unverifiable est délibérée : un verdict failed est toujours attribuable à l’enregistrement lui-même, de sorte qu’aucun explorateur malveillant ne peut en fabriquer un ; unverifiable signifie que le vérificateur n’a pu mener une vérification à son terme pour des raisons extérieures à l’enregistrement — une passerelle qu’il n’a pu atteindre, un hôte en liste de blocage ou un plafond de récupération.

Ajoutez --json pour un rapport lisible par une machine, et gardez chaque saut réseau sous votre contrôle en pointant vers votre propre infrastructure :

cardanowall verify 3b9f…c1a2 \
  --cardano-gateway https://your-koios-instance/api/v1 \
  --threshold 20 \
  --json

Si l’enregistrement vous est scellé, remettez votre clé au vérificateur : il déchiffrera la charge utile et recalculera l’empreinte du texte en clair :

cardanowall verify 3b9f…c1a2 --secret-key-stdin

Préférez --secret-key-stdin, --secret-key-file ou la variable d’environnement CARDANOWALL_RECIPIENT_KEY à un simple drapeau --secret-key, afin que la clé n’atterrisse jamais dans l’historique de votre shell.

Avec le SDK TypeScript

Le vérificateur qu’utilise la CLI est livré dans le SDK. Il n’a besoin d’aucun client, d’aucune URL de base et d’aucune clé : la vérification est indépendante de la passerelle :

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

const report = await verifyTx({ txHash: '3b9f…c1a2' });

console.log(report.verdict); // 'valid' | 'pending' | 'unverifiable' | 'failed'

if (report.verdict !== 'valid') {
  console.error(report.issues, report.signatures);
}

verifyTx renvoie un VerifyReport complet : le verdict et exitCode, le block_time et la confirmationDepth résolus, la liste issues des problèmes structurels et du vérificateur, les résultats de contrôle par élément items et merkle, les signatures optionnelles et un journal auditTrail de chaque requête sortante qu’il a effectuée — de sorte que vous puissiez vous prouver à vous-même qu’il n’a jamais contacté le publicateur.

Pour vérifier un enregistrement qui vous est scellé, remettez votre clé privée au vérificateur. Le trousseau de clés est global à l’exécution : chaque clé que vous transmettez est essayée contre chaque élément scellé, il n’y a donc aucun index par élément :

const report = await verifyTx({
  txHash: '3b9f…c1a2',
  decryption: [{ recipientSecretKey: mySecretKey }],
});

Avec le SDK Python

cardanowall-sdk est un jumeau octet pour octet du vérificateur TypeScript : les mêmes vérifications, le même verdict :

import asyncio
import cardanowall

report = asyncio.run(cardanowall.verify_tx(cardanowall.VerifyTxInput(tx_hash="3b9f…c1a2")))
print(report.verdict)

Avec le SDK Rust

Le crate cardanowall embarque le même vérificateur. verify_tx est synchrone — il incorpore un transport bloquant — et renvoie le même VerifyReport :

use cardanowall::verifier::{verify_tx, Verdict, VerifyTxInput};

let report = verify_tx(&VerifyTxInput::new("3b9f…c1a2"));

println!("{}", report.verdict.as_str()); // "valid" | "pending" | "unverifiable" | "failed"

if report.verdict != Verdict::Valid {
    eprintln!("{:?}", report.issues);
    eprintln!("{:?}", report.record_signatures);
}

Pour vérifier un enregistrement qui vous est scellé, joignez votre clé privée. Le trousseau de clés est global à l’exécution : chaque clé est essayée contre chaque élément scellé, de sorte qu’un identifiant ne porte aucun index d’élément. Les champs d’entrée sont publics, construisez donc par-dessus VerifyTxInput::new :

use cardanowall::verifier::{verify_tx, Decryption, VerifyTxInput};

let mut input = VerifyTxInput::new("3b9f…c1a2");
input.decryption = Some(vec![Decryption::Recipient {
    recipient_secret_key: my_secret_key, // Vec<u8>
}]);

let report = verify_tx(&input);