Proofivy Concepts Guide

Proofivy is a blockchain-based platform that helps creators protect and earn from their work. Commit a fingerprint of your files, plans, or ideas to the blockchain as immutable, timestamped proof — without exposing sensitive data. Monetize your content with automatic micropayments when AI agents or humans access it, or convert your proofs into tradeable NFTs.

Core Problems Solved

Digital Provenance

  • Establishing true ownership of digital assets is challenging
  • Proving the creation date of digital content is difficult
  • No standardized way to track IP ownership and transfers

IP Protection

  • Trillions of dollars worth of IP are locked in opaque legal structures
  • Traditional IP protection is slow, expensive, and often jurisdiction-dependent
  • Digital works are easily copied and harder to protect

Content Monetization

  • AI agents read publisher content every day without compensation
  • Publishers face an impossible choice: block AI bots and lose reach, or let them scrape freely and lose revenue
  • No standardized way to charge for AI access to content

How Proofivy Works

Digital Seals

A digital seal in Proofivy is like a tamper-proof timestamp for your digital content. Here's how it works:

  1. Hash Creation: Your content is converted into a unique fingerprint (hash)
  2. Blockchain Recording: This fingerprint is stored on the blockchain
  3. Verification: Check if a file's fingerprint is committed to the blockchain

NFT Integration

Unleashing Proofs

Proofivy allows converting proofs into NFTs, enabling:

  • Trading of IP rights
  • Monetization of digital assets
  • Transparent ownership transfers

Use Cases

Creative Industries

  • Photographers protecting image rights
  • Writers establishing manuscript ownership
  • Artists proving artwork originality

Scientific Research

  • Timestamping research findings
  • Protecting experimental data
  • Establishing priority of discovery

Business Innovation

  • Protecting trade secrets
  • Documenting development stages
  • Managing employee innovations

Publishers

  • Monetizing AI traffic with automatic micropayments via x402
  • Keeping access free for humans while charging AI agents
  • Earning stablecoin revenue for every AI lookup

Legal Documentation

  • Timestamping contracts
  • Proving document existence
  • Managing legal evidence

Integration Options

Direct Usage

  • Desktop applications
  • Mobile apps
  • Command-line tools

Platform Integration

  • API access
  • Single sign-on options
  • Custom implementations

Enterprise Solutions

  • Custom deployment options
  • Specialized features
  • Integration support

Smart Contract Documentation

This documentation covers the smart contract interfaces for both the main Proofivy contract and the Unleash NFT contract.

Core Concepts

Proofivy operates with several key concepts:

  • CID: Content ID, notation standard that includes hashing method and hash. Currently all our apps are using SHA256, we are experimenting with BLAKE3 and other hashing methods
  • Commits: CID's stored on the blockchain that prove the existence of data at a specific time
  • Signed Commits: Similar to commits but include a cryptographic signature from an Ethereum address. An example is our iPhone app, commits are uniquely linked to the iPhone user, but committed by a Proofivy owned Ethereum wallet
  • Messages: Users can also post plain text messages onchain through Proofivy (can also be signed)
  • Guilds: Onboarded groups of users (for example companies, organizations). Contact us to be onboarded
  • NFT Unleashing: Converting proofs into tradeable NFTs

Pricing

  • Public operations require payment in ETH, current price for commit is 0.001 ETH, for message is 0.002 ETH
  • Guild operations are free for guild members, requires onboarding and subscription
  • NFT unleashing is free

x402 Content Monetization

Proofivy provides x402 infrastructure that lets publishers monetize AI traffic with automatic micropayments. AI agents pay in Base USDC to access content, with payments settled onchain in seconds.

  • x402scan — Monitor x402 payment activity on Proofivy's server

Contract Links

Proofivy V2 | Unleash | NFT | Proofivy V1 (old) | Proofivy (old)

Public Operations

public_commit

Creates a public commit on the blockchain.

@external
@payable
def public_commit(hash: String[64]):
    assert msg.value >= self.public_commit_price, 'Insufficient funds'
    raw_call(self.contract_owner, b"", value=msg.value)
    self.public_commit_counter += 1
    self.public_commit_senders[self.public_commit_counter] = msg.sender
    self.public_commits[self.public_commit_counter] = hash
    log PublicCommit(msg.sender, hash, self.public_commit_counter)
  • Parameters: hash — Hash of the data to commit
  • Cost: Current public commit price

signed_public_commit

Creates a signed public commit with cryptographic proof.

@external
@payable
def signed_public_commit(hash: String[64], signature: Bytes[65]):
    assert msg.value >= self.public_commit_price, 'Insufficient funds'
    raw_call(self.contract_owner, b"", value=msg.value)
    self.signed_public_commit_counter += 1
    self.signed_public_commit_senders[self.signed_public_commit_counter] = msg.sender
    self.signed_public_commits[self.signed_public_commit_counter] = hash
    self.signed_public_commit_signatures[self.signed_public_commit_counter] = signature
    log SignedPublicCommit(msg.sender, hash, self.signed_public_commit_counter, signature)
  • Parameters: hash, signature
  • Cost: Current public commit price

Guild Operations

guild_commit

Creates a commit within a guild.

@external
def guild_commit(guild: String[99], hash: String[64]):
    assert self.guild_members[guild][msg.sender], 'Not a member'
    self.guild_commit_counter[guild] += 1
    self.guild_commit_senders[guild][self.guild_commit_counter[guild]] = msg.sender
    self.guild_commits[guild][self.guild_commit_counter[guild]] = hash
    log GuildCommit(guild, msg.sender, hash, self.guild_commit_counter[guild])
  • Parameters: guild, hash
  • Access: Guild members only

signed_guild_commit

Creates a signed commit within a guild.

@external
def signed_guild_commit(guild: String[99], hash: String[64], signature: Bytes[65]):
    assert self.guild_members[guild][msg.sender], 'Not a member'
    self.signed_guild_commit_counter[guild] += 1
    self.signed_guild_commit_senders[guild][self.signed_guild_commit_counter[guild]] = msg.sender
    self.signed_guild_commits[guild][self.signed_guild_commit_counter[guild]] = hash
    self.signed_guild_commit_signatures[guild][self.signed_guild_commit_counter[guild]] = signature
    log SignedGuildCommit(guild, msg.sender, hash, self.signed_guild_commit_counter[guild], signature)
  • Parameters: guild, hash, signature
  • Access: Guild members only

Main Contract Events

PublicCommit

event PublicCommit:
    sender: indexed(address)
    hash: String[64]
    public_commit_count: uint256

SignedPublicCommit

event SignedPublicCommit:
    sender: indexed(address)
    hash: String[64]
    signed_public_commit_count: uint256
    signature: Bytes[65]

GuildCommit

event GuildCommit:
    guild: String[99]
    sender: indexed(address)
    hash: String[64]
    guild_commit_count: uint256

SignedGuildCommit

event SignedGuildCommit:
    guild: String[99]
    sender: indexed(address)
    hash: String[64]
    signed_guild_commit_count: uint256
    signature: Bytes[65]

Unleash Contract

The Unleash contract allows converting Proofivy commits into NFTs, enabling monetization and trading of intellectual property rights.

unleash_public_commit

Converts a public commit into an NFT.

@external
@payable
def unleash_public_commit(commit_number: uint256):
    assert msg.value >= self.public_unleash_price, 'Insufficient funds'
    raw_call(self.contract_owner, b"", value=msg.value)
    commit_cid: String[64] = staticcall Proofivy(self.proofivy_contract).public_commits(commit_number)
    commit_sender: address = staticcall Proofivy(self.proofivy_contract).public_commit_senders(commit_number)
    assert msg.sender == commit_sender, 'Only the sender of the commit can unleash it'
    assert self.public_commits_unleashed[commit_number] == 0, 'Commit already unleashed'
    self.nft_counter += 1
    self.public_commits_unleashed[commit_number] = self.nft_counter
    self.public_commit_nfts[self.nft_counter] = commit_number
    extcall NFT(self.nft_contract).safeMint(msg.sender, self.nft_counter)
    log MintPublicCommitNFT(msg.sender, commit_cid, self.nft_counter, commit_number)
  • Parameters: commit_number — ID of the commit to unleash
  • Cost: Current unleash price (0 ETH currently)

unleash_signed_public_commit

Converts a signed public commit into an NFT.

@external
@payable
def unleash_signed_public_commit(commit_number: uint256, signature: Bytes[65], mint_address: address):
    assert msg.value >= self.public_unleash_price, 'Insufficient funds'
    raw_call(self.contract_owner, b"", value=msg.value)
    commit_cid: String[64] = staticcall Proofivy(self.proofivy_contract).signed_public_commits(commit_number)
    commit_signature: Bytes[65] = staticcall Proofivy(self.proofivy_contract).signed_public_commit_signatures(commit_number)
    assert self.signed_public_commits_unleashed[commit_number] == 0, 'Commit already unleashed'
    ...
    self.nft_counter += 1
    self.signed_public_commits_unleashed[commit_number] = self.nft_counter
    self.signed_public_commit_nfts[self.nft_counter] = commit_number
    extcall NFT(self.nft_contract).safeMint(mint_address, self.nft_counter)
    log MintSignedPublicCommitNFT(msg.sender, commit_signature_address, mint_address, commit_cid, self.nft_counter, commit_number)
  • Parameters: commit_number, signature, mint_address
  • Cost: Current unleash price (0 ETH currently)

unleash_guild_commit

Converts a guild commit into an NFT.

@external
def unleash_guild_commit(commit_number: uint256, guild: String[99]):
    commit_cid: String[64] = staticcall Proofivy(self.proofivy_contract).guild_commits(guild, commit_number)
    commit_sender: address = staticcall Proofivy(self.proofivy_contract).guild_commit_senders(guild, commit_number)
    assert msg.sender == commit_sender, 'Only the sender of the commit can unleash it'
    assert staticcall Proofivy(self.proofivy_contract).guild_members(guild, msg.sender), 'Sender is not a guild member'
    assert self.guild_commits_unleashed[guild][commit_number] == 0, 'Commit already unleashed'
    self.nft_counter += 1
    self.guild_commits_unleashed[guild][commit_number] = self.nft_counter
    self.guild_commit_nfts[guild][self.nft_counter] = commit_number
    extcall NFT(self.nft_contract).safeMint(msg.sender, self.nft_counter)
    log MintGuildCommitNFT(msg.sender, guild, commit_cid, self.nft_counter, commit_number)
  • Parameters: commit_number, guild
  • Access: Guild members only

Unleash Contract Events

MintPublicCommitNFT

event MintPublicCommitNFT:
    sender: indexed(address)
    cid: String[64]
    token_id: uint256
    commit_number: uint256

MintSignedPublicCommitNFT

event MintSignedPublicCommitNFT:
    sender: indexed(address)
    signer: indexed(address)
    mint_address: indexed(address)
    cid: String[64]
    token_id: uint256
    commit_number: uint256

MintGuildCommitNFT

event MintGuildCommitNFT:
    sender: indexed(address)
    guild: String[99]
    cid: String[64]
    token_id: uint256
    commit_number: uint256

MintSignedGuildCommitNFT

event MintSignedGuildCommitNFT:
    sender: indexed(address)
    guild: String[99]
    signer: indexed(address)
    mint_address: indexed(address)
    cid: String[64]
    token_id: uint256
    commit_number: uint256