TypeScript / JavaScript SDK

npm install @uverify/sdk
# or
yarn add @uverify/sdk
# or
pnpm add @uverify/sdk

import { UVerifyClient } from '@uverify/sdk';
 
const client = new UVerifyClient();
 
const certificates = await client.verify('a3b4c5d6...');
console.log(certificates);

import { UVerifyClient } from '@uverify/sdk';
 
// Connect to the public API (default)
const client = new UVerifyClient();
 
// Connect to a self-hosted instance
const client = new UVerifyClient({ baseUrl: 'http://localhost:9090' });
 
// Register default signing callbacks so you don't pass them on every call
const client = new UVerifyClient({
  signMessage: async (message) => wallet.signData(address, message),
  signTx: (unsignedTx) => wallet.signTx(unsignedTx, true),
});
 
// Override the verification base URL for deep links (used by client.apps)
// Defaults automatically: preprod API → preprod app, production API → production app
const client = new UVerifyClient({
  signMessage,
  signTx,
  verifyBaseUrl: 'https://app.uverify.io/verify',
});

// By data hash
const certs = await client.verify('sha256-or-sha512-hex-hash');
 
// By transaction hash + data hash
const cert = await client.verifyByTransaction('cardano-tx-hash', 'data-hash');

import { UVerifyClient } from '@uverify/sdk';
import { MeshCardanoHeadlessWallet, AddressType } from '@meshsdk/wallet';
import { KoiosProvider } from '@meshsdk/core';
import { sha256 } from 'js-sha256';
 
const provider = new KoiosProvider('preprod');
const wallet = await MeshCardanoHeadlessWallet.fromMnemonic({
  networkId: 0,
  walletAddressType: AddressType.Base,
  fetcher: provider,
  submitter: provider,
  mnemonic: ['word1', 'word2', /* ... */],
});
const address = await wallet.getChangeAddressBech32();
 
const client = new UVerifyClient({
  signMessage: (message) => wallet.signData(address, message),
  signTx: (unsignedTx) => wallet.signTx(unsignedTx, true),
});
 
const txHash = await client.issueCertificates(address, [
  {
    hash: sha256('Hello, UVerify!'),
    algorithm: 'SHA-256',
    metadata: { issuer: 'Acme Corp', date: new Date().toISOString() },
  },
]);
console.log('Certified at tx:', txHash);

const txHash = await client.issueCertificates(
  address,
  [{ hash: 'sha256-hash' }],
  undefined,       // use constructor signTx
  'my-state-id',
);

const state = await client.getUserInfo(address);
console.log('Certificates remaining:', state?.countdown);
 
if (state?.id) {
  await client.invalidateState(address, state.id);
  await client.optOut(address, state.id);
}

// Build
const { unsignedTransaction } = await client.core.buildTransaction({
  type: 'default',
  address: 'addr1...',
  stateId: 'your-state-id',
  certificates: [{ hash: 'sha256-hash', algorithm: 'SHA-256' }],
});
 
// Sign with your wallet, then submit
const witnessSet = await wallet.signTx(unsignedTransaction, true);
const txHash = await client.core.submitTransaction(unsignedTransaction, witnessSet);

// Two-step user state action (manual)
const challenge = await client.core.requestUserAction({
  address: 'addr1...',
  action: 'USER_INFO',
});
 
const { key, signature } = await wallet.signData(address, challenge.message);
 
const result = await client.core.executeUserAction({
  ...challenge,
  userSignature: signature,
  userPublicKey: key,
});
console.log(result.state);

import { UVerifyClient } from '@uverify/sdk';
 
const client = new UVerifyClient({ signMessage, signTx });
 
const result = await client.apps.issueDiploma(address, [
  {
    studentId: 'TUM-2021-0042',
    name: 'Maria Müller',
    degree: 'Master of Science in Computer Science',
    institution: 'Technical University of Munich',
    graduationDate: '2024-06-28',
    honors: 'Summa Cum Laude',       // optional
  },
  {
    studentId: 'TUM-2021-0117',
    name: 'Felix Schmidt',
    degree: 'Master of Science in Computer Science',
    institution: 'Technical University of Munich',
    graduationDate: '2024-06-28',
  },
]);
 
console.log('Transaction:', result.txHash);
 
for (const cert of result.certificates) {
  // verifyUrl includes ?name= so the certificate page reveals the recipient's name
  console.log(`${cert.name}: ${cert.verifyUrl}`);
}

const { txHash, verifyUrl } = await client.apps.issueDigitalProductPassport(address, {
  name: 'EcoCharge Powerbank Pro 200',
  manufacturer: 'GreenTech AG',
  gtin: '04012345678901',
  serialNumber: 'EC200-SN-20240815-00847',
  model: 'EC-200-2024',
  origin: 'Germany',
  manufactured: '2024-08-15',
  contact: 'sustainability@greentech-ag.example',
  brandColor: '#1a56db',
  carbonFootprint: '1.2 kg CO₂e',
  recycledContent: '38%',
  energyClass: 'A++',
  warranty: '3 years',
  spareParts: 'Available until 2034',
  repairInfo: 'https://greentech-ag.example/repair/ec-200',
  recycling: 'Return to any EU-authorised WEEE recycling point.',
  materials: { aluminum: '45%', recycled_plastic: '38%', lithium_cells: '12%' },
  certifications: { ce: 'CE Marking', rohs: 'RoHS Compliant', energy_star: 'Energy Star 8.0' },
});
 
// verifyUrl includes ?serial= so the certificate page can reveal the serial number
console.log('Passport URL:', verifyUrl);

const result = await client.apps.issueLaboratoryReport(address, [
  {
    reportId: 'BMD-2024-10-00123',
    patientName: 'Sophie Wagner',
    labName: 'Berlin Medical Diagnostics GmbH',
    contact: 'results@bmd-lab.example',
    auditable: true,
    values: {
      glucose: '5.4 mmol/L',
      hba1c: '5.7%',
      cholesterol: '4.9 mmol/L',
    },
  },
]);
 
for (const cert of result.certificates) {
  // verifyUrl includes ?name=&report_id= to reveal patient name and report ID
  console.log(`${cert.patientName} / ${cert.reportId}: ${cert.verifyUrl}`);
}

import { UVerifyApiError, UVerifyValidationError } from '@uverify/sdk';
 
try {
  const txHash = await client.issueCertificates(address, certs);
} catch (err) {
  if (err instanceof UVerifyApiError) {
    console.error(`API error ${err.statusCode}:`, err.responseBody);
  }
  if (err instanceof UVerifyValidationError) {
    console.error(err.message);
  }
}