Proofivy

Proofivy Documentation

Proofivy Concepts Guide

Proofivy is a blockchain-based platform that provides irrefutable proof of intellectual property (IP), copyright, and ideas. It allows creators, innovators, and businesses to establish timestamped proof of their work without exposing sensitive data. Proofivy also allows creators to monetize their work by trading copyrights and licensing rights and allows advanced options like automated royalty distributions.

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 and Monetization

  • 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

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 files 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

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

Proofivy 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, can be committed by anyone using an Ethereum wallet
  • Signed Commits: Similar to commits but include a cryptographic signature from an Ethereum address. Signed commits allow one entity (like a platform) to manage commits on behalf of users while preserving user ownership through signatures. 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. These users can commit under a guild through a subscription
  • 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 that includes apps, API's, and service
  • NFT unleashing is free

Contracts

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

Main Contract

Below a list of the main functions and events.

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: Hash of the data to commit
    • signature: Cryptographic 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: Guild name
    • hash: Hash to commit
  • 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: Guild name
    • hash: Hash to commit
    • signature: Cryptographic signature

  • Access: Guild members only

    Main Contract Events

PublicCommit

Emitted when a public commit is created.

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

SignedPublicCommit

Emitted when a signed public commit is created.

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

GuildCommit

Emitted when a guild commit is created.

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

SignedGuildCommit

Emitted when a signed guild commit is created.

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. Below the main functions and events.

NFT Operations

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):
    # signature message: 'public unleash {commit_number} {commit_cid}'
    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'
    commit_signature_hash: bytes32 = self.message_to_hash(commit_cid)
    commit_signature_address: address = self.get_address_from_signature(commit_signature, commit_signature_hash)
    unleash_signature_hash: bytes32 = self.message_to_hash(concat('public unleash ', uint2str(commit_number), ' ', commit_cid))
    unleash_signature_address: address = self.get_address_from_signature(signature, unleash_signature_hash)
    assert commit_signature_address == unleash_signature_address, 'Invalid signature'

    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: ID of the commit to unleash
    • signature: Original signature
    • mint_address: Address to receive the NFT
  • 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: ID of the commit to unleash
    • guild: Guild name
  • Access: Guild members only

Unleash Contract Events

MintPublicCommitNFT

Emitted when a public commit is converted to an NFT.

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

MintSignedPublicCommitNFT

Emitted when a signed public commit is converted to an NFT.

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

MintGuildCommitNFT

Emitted when a guild commit is converted to an NFT.

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

MintSignedGuildCommitNFT

Emitted when a signed guild commit is converted to an NFT.

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