Provifier — Trustless Off-Chain Data Integrity

Prove your data hasn't changed. No middleman.

Provifier lets any application hash its data and commit that hash on-chain. Verification is trustless: re-hash locally, compare to the blockchain. No data goes on-chain — only 64-character SHA-256 hashes.

npm install @provifier/sdk View source

How it works

1 Hash your data

Your app calls Provifier.hashRecord(table, rowId, data). Domain-separated SHA-256 ensures hashes are unique per table and row — no cross-protocol collisions.

2 Commit hash on-chain

The hash is signed and submitted to Sui (Move contract event) or Solana (SPL Memo). Server-side with a private key, or client-side via the user's wallet — your choice.

3 Verify anytime

Re-hash the data, fetch the on-chain event, compare. If they match, the data is authentic and hasn't been tampered with since commitment. Fully trustless — the blockchain is the referee.

Key features

Multi-chain

Sui + Solana from day one

Merkle batching

Commit thousands of records in one transaction

Client-side signing

Users commit from their own wallet (Sui)

Domain separation

Hashes scoped by table + row ID

Zero on-chain data

Only 64-char hashes, never your data

MIT licensed

Free, open source, no lock-in

Quick start

npm install @provifier/sdk

const { Provifier } = require('@provifier/sdk');

const p = new Provifier({
  chain: 'sui',
  network: 'testnet',
  privateKey: process.env.SUI_PRIVATE_KEY,
  packageId: '0x...',   // deployed Move contract
});

// Commit a record
const receipt = await p.commit({
  table: 'documents',
  rowId: 'doc-7',
  data: documentContent,
});
console.log(receipt.txDigest);    // Sui transaction digest
console.log(receipt.explorerUrl); // https://suiscan.xyz/testnet/tx/...

// Verify later — trustless
const result = await p.verify({
  table: 'documents',
  rowId: 'doc-7',
  data: documentContent,
  txDigest: receipt.txDigest,
});
console.log(result.valid); // true

Batch commits (Merkle tree)

Commit many records in a single transaction. Each entry gets a Merkle proof for individual verification.

const batch = await p.commitBatch({
  entries: [
    { table: 'users', rowId: '1', data: JSON.stringify(user1) },
    { table: 'users', rowId: '2', data: JSON.stringify(user2) },
    { table: 'users', rowId: '3', data: JSON.stringify(user3) },
  ],
});

// Verify one entry from the batch
const result = await p.verify({
  table: 'users',
  rowId: '2',
  data: JSON.stringify(user2),
  merkleProof: batch.receipts[1].merkleProof,
  merkleRoot: batch.receipts[1].merkleRoot,
  txDigest: batch.txDigest,
});
console.log(result.valid); // true

Client-side wallet signing

For dApps where the user commits from their own wallet — maximum trust, zero server dependency.

const p = new Provifier({
  chain: 'sui',
  network: 'mainnet',
  packageId: '0x...',
  // No privateKey — client-side mode
});

const { transaction, hash } = p.buildCommitTx({
  table: 'documents',
  rowId: 'doc-7',
  data: documentContent,
});

// Pass to user's wallet (Sui Wallet, Suiet, zkLogin)
const result = await wallet.signAndExecuteTransaction({
  transaction,
});

Multi-chain

Sui

Move contract with typed events

Structured event queries

Client-side wallet signing

~$0.001 per commit

Recommended

Solana

SPL Memo program — no deploy needed

Parse from transaction logs

Lowest possible cost

~$0.0005 per commit

Zero setup

Use cases

💾

dApps with off-chain data

Games, social platforms, marketplaces — commit off-chain state hashes so users can verify their data hasn't been silently altered.

📜

Compliance and audit trails

Financial records, healthcare data, legal documents — prove what existed when, with cryptographic certainty anchored to the blockchain.

🔒

Supply chain integrity

Hash shipment records, certificates, or sensor data at each checkpoint. Any tampering breaks the chain of proof.

⚙

Configuration drift detection

Commit config file hashes on deploy. Later, re-hash and compare to detect unauthorized changes.

Sui Move contract

Deploy once, use forever. The contract emits events — no stored objects, cheapest possible on-chain operation.

// Two event types:
// HashCommitted  — single record: committer, table, row_id, data_hash, timestamp
// BatchCommitted — Merkle batch: committer, merkle_root, leaf_count, timestamp

cd contracts/sui
sui move build
sui client publish --gas-budget 100000000

API reference

Method	Returns	Description
`Provifier.hash(data)`	string	SHA-256 with `provifier:v1:` domain prefix
`Provifier.hashRecord(table, rowId, data)`	string	Domain-separated hash per table/row
`commit({ table, rowId, data })`	Promise<Receipt>	Commit a single hash on-chain
`commitBatch({ entries })`	Promise<BatchResult>	Merkle batch commit
`verify({ ... })`	Promise<VerifyResult>	Re-hash + on-chain comparison
`buildCommitTx({ ... })`	{ transaction, hash }	Unsigned Sui tx for wallet signing

Hosted API

Don't want to manage keys and chain connections? Use the hosted API at provifier.com. Same SDK — just point it at our endpoint instead of running your own.

Self-hosted

Deploy your own instance

Your keys, your chain costs

Unlimited commits

Free forever (MIT)

provifier.com

No setup — just get an API key

We handle chain transactions

1 credit per commit ($0.01)

Verify: always free

Pay-as-you-go

25 free credits/week

# Hosted API — no SDK needed, just curl
curl -X POST https://provifier.com/v1/commit \
  -H "X-Provifier-Key: pvf_live_..." \
  -H "Content-Type: application/json" \
  -d '{"table":"docs","rowId":"doc-7","data":"Hello world"}'

# Verify (free, no auth)
curl https://provifier.com/v1/verify/SuiTxDigest...

Get API key Buy credits

Testing

cd packages/sdk
node --test test/sdk.test.js
# 25 tests — hashing, Merkle trees, commit/verify, tamper detection
# Uses mock chain adapters — no network access needed