CertiSigma SDKs

npm install @certisigma/sdk

const { CertiSigmaClient } = require('@certisigma/sdk');

const client = new CertiSigmaClient({
  apiKey: process.env.CERTISIGMA_API_KEY,
});

const { CertiSigmaClient, hashFile, hashBytes } = require('@certisigma/sdk');
const fs = require('fs');

const client = new CertiSigmaClient({ apiKey: 'cs_live_your_key_here' });

// 1. Compute the SHA-256 hash of your file
const fileHash = await hashFile(fs.readFileSync('contract.pdf'));
console.log(`SHA-256: ${fileHash}`);  // 64-char lowercase hex

// 2. Attest — creates a timestamped, signed proof of existence
const result = await client.attest(fileHash, { source: 'my-app' });
console.log(`Attestation: ${result.id} at ${result.timestamp}`);

// 3. Verify — confirm the hash was attested
const check = await client.verify(fileHash);
console.log(`Exists: ${check.exists}, Level: ${check.level}`);

// Or hash raw bytes directly
const dataHash = await hashBytes(new TextEncoder().encode('any raw content'));
const result2 = await client.attest(dataHash);

const { CertiSigmaClient, hashFile } = require('@certisigma/sdk');
const fs = require('fs');

const client = new CertiSigmaClient({ apiKey: process.env.CERTISIGMA_API_KEY });

// 1. Hash the file locally (SHA-256 via Web Crypto API)
const hashHex = await hashFile(fs.readFileSync('contract.pdf'));

// 2. Attest
const result = await client.attest(hashHex, { source: 'contract-pipeline' });

// 3. Save to a local JSON manifest
const manifest = {
  id: result.id,
  hash: result.hash_hex,
  timestamp: result.timestamp,
  signature: result.signature,
  source: 'contract-pipeline',
};
fs.writeFileSync('contract.pdf.certisigma.json', JSON.stringify(manifest, null, 2));

// 4. Later — download evidence (includes T2 when available)
const evidence = await client.getEvidence(result.id);
console.log(`Level: ${evidence.level}`);

// 5. Update manifest with evidence
manifest.level = evidence.level;
manifest.t1 = evidence.t1;
manifest.t2 = evidence.t2;
fs.writeFileSync('contract.pdf.certisigma.json', JSON.stringify(manifest, null, 2));

{
  "id": "att_a1b2c3d4e5f6",
  "hash": "e3b0c44298fc1c149afbf4c8996fb924...",
  "timestamp": "2025-06-15T10:30:00Z",
  "signature": "MEUCIQDx...",
  "source": "contract-pipeline",
  "original_file": "contract.pdf",
  "level": "T2",
  "t1": { "batchId": 42, "merkleRoot": "c4f3b2...", "tsaTimestamp": "2025-06-15T10:35:00Z" },
  "t2": {
    "bitcoinBlockHeight": 850123,
    "bitcoinBlockHash": "00000000000000000002a7c4...",
    "bitcoinTxid": "d4e5f6a7b8c9...",
    "confirmedAt": "2025-06-15T14:20:00Z"
  }
}

const { hashFile } = require('@certisigma/sdk');
const fs = require('fs');

// Compute hashes for all invoices
const files = fs.readdirSync('invoices/').filter(f => f.endsWith('.pdf'));
const hashes = await Promise.all(
  files.map(f => hashFile(fs.readFileSync(`invoices/${f}`)))
);

// Attest up to 100 hashes in one call
const batch = await client.batchAttest(hashes, { source: 'invoice-processor' });
console.log(`Created: ${batch.created}, Existing: ${batch.existing}`);

// Later — verify the same files haven't been tampered with
const currentHashes = await Promise.all(
  files.map(f => hashFile(fs.readFileSync(`invoices/${f}`)))
);
const results = await client.batchVerify(currentHashes);
console.log(`Found: ${results.found}/${results.count}`);

// Browser — from a file input
const file = document.getElementById('fileInput').files[0];
const result = await client.attestFile(file, { source: 'upload-form' });

// Node.js — from a buffer
const buf = fs.readFileSync('document.pdf');
const result2 = await client.attestFile(buf, { source: 'cli-tool' });

const { hashFile, hashBytes } = require('@certisigma/sdk');
// or: const { hashFile, hashBytes } = require('@certisigma/sdk/hash');

// Hash a File, Blob, ArrayBuffer, or Uint8Array
const fileHash = await hashFile(fileInput.files[0]);
console.log(`SHA-256: ${fileHash}`);  // 64-char hex

// Hash raw bytes
const dataHash = await hashBytes(new TextEncoder().encode('raw content'));

// Verify a file against a known hash
const currentHash = await hashFile(fileInput.files[0]);
console.assert(currentHash === fileHash);

// Node.js — hash a local file for batch preparation
const fs = require('fs');
const hashes = await Promise.all(
  filePaths.map(p => hashBytes(fs.readFileSync(p)))
);
const batch = await client.batchAttest(hashes, { source: 'bulk-ingest' });

// Update claim metadata
await client.updateMetadata('att_1234', {
  source: 'pipeline-v2',
  extraData: { project: 'alpha', version: '2.0' },
});

// Soft-delete claim
await client.deleteMetadata('att_1234');

// Get full cryptographic evidence
const evidence = await client.getEvidence('att_1234');

const { generateKey, encryptMetadata, decryptMetadata } = require('@certisigma/sdk/crypto');

// Generate a key (store securely — server never sees it)
const key = await generateKey();

// Encrypt before sending
const encrypted = await encryptMetadata({ secret: 'classified' }, key);
await client.attest(hash, { extraData: encrypted, clientEncrypted: true });

// Decrypt after retrieving
const result = await client.verify(hash);
const plaintext = await decryptMetadata(result.extra_data, key);

// Verify a single hash
const check = await client.verify('e3b0c44...');
if (check.exists) {
  console.log(`Attested at ${check.timestamp}, Level: ${check.level}`);
}

// Verify from a saved manifest
const manifest = JSON.parse(fs.readFileSync('contract.pdf.certisigma.json', 'utf8'));
const check2 = await client.verify(manifest.hash);
console.log(`Level: ${check2.level}`);

// Batch verify (up to 100)
const results = await client.batchVerify(['aabb...', 'ccdd...']);
results.results.forEach(r => console.log(`${r.hash_hex}: ${r.exists}`));

const { CertiSigmaClient, hashFile } = require('@certisigma/sdk');
const fs = require('fs');

// No apiKey needed — public verification
const client = new CertiSigmaClient();

const fileHash = await hashFile(fs.readFileSync('contract.pdf'));
const check = await client.verify(fileHash);
console.log(`Exists: ${check.exists}, Level: ${check.level}`);

// Batch verify also works without a key
const results = await client.batchVerify([fileHash]);
console.log(`Found: ${results.found}/${results.count}`);

const { RateLimitError } = require('@certisigma/sdk');

async function attestWithBackoff(client, hashHex, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await client.attest(hashHex);
    } catch (err) {
      if (err instanceof RateLimitError) {
        const wait = err.retryAfter * 1000 * (2 ** i);
        await new Promise(r => setTimeout(r, wait));
      } else throw err;
    }
  }
  throw new Error('Max retries exceeded');
}

async function waitForT1(client, attId, timeoutMs = 600000) {
  const start = Date.now();
  while (Date.now() - start < timeoutMs) {
    const s = await client.status(attId);
    if (s.level === 'T1' || s.level === 'T2') return s;
    await new Promise(r => setTimeout(r, 30000));
  }
  throw new Error('T1 not reached within timeout');
}

const crypto = require('crypto');

function verifyWebhook(bodyBuffer, secret, signatureHeader) {
  const expected = 'sha256=' + crypto
    .createHmac('sha256', secret)
    .update(bodyBuffer)
    .digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(expected),
    Buffer.from(signatureHeader)
  );
}

const { CertiSigmaClient, getBlockchainUrl, saveOtsProof } = require('@certisigma/sdk');
const fs = require('fs');

const client = new CertiSigmaClient({ apiKey: process.env.CERTISIGMA_API_KEY });

// Retrieve the full evidence bundle
const evidence = await client.getEvidence('att_1234');
console.log(`Level: ${evidence.level}`);  // "T0", "T1", or "T2"

if (evidence.level === 'T2') {
  // Get the Bitcoin block explorer link
  const blockUrl = getBlockchainUrl(evidence);              // mempool.space/block/...
  const txUrl    = getBlockchainUrl(evidence, 'tx');      // mempool.space/tx/...
  console.log(`Block: ${blockUrl}`);
  console.log(`Tx:    ${txUrl}`);
  console.log(`Height: ${evidence.t2.bitcoinBlockHeight}`);

  // Save the raw .ots proof (for independent OTS verification)
  saveOtsProof(evidence, 'contract.pdf.ots');

  // Update your local manifest
  const manifest = JSON.parse(fs.readFileSync('contract.pdf.certisigma.json', 'utf8'));
  manifest.level = evidence.level;
  manifest.t2 = evidence.t2;
  fs.writeFileSync('contract.pdf.certisigma.json', JSON.stringify(manifest, null, 2));
}

# Install the OpenTimestamps client
pip install opentimestamps-client

# Verify the proof against the Bitcoin blockchain
ots verify contract.pdf.ots

# Or verify online at https://opentimestamps.org

const { AuthenticationError, RateLimitError, QuotaExceededError } = require('@certisigma/sdk');

try {
  await client.attest(hash);
} catch (err) {
  if (err instanceof AuthenticationError) {
    console.error('Invalid API key');
  } else if (err instanceof RateLimitError) {
    console.error(`Rate limited, retry after ${err.retryAfter}s`);
  } else if (err instanceof QuotaExceededError) {
    console.error('Monthly quota reached');
  }
}