infrablockchain-docs
en
en
  • InfraBlockchain
    • Learn
      • Architecture
        • Architecture
        • Network Participants
        • Parachain
          • System Parachains
      • Protocol
        • System Token
        • Transaction Fee
        • Proof of Transaction
      • Substrate
        • Learn
          • Basic
            • Cryptography
            • Blockchain Basics
            • Consensus
            • Networks and Nodes
            • Blockchain Transaction
            • Transaction Life Cycle
            • Offchain Operations
            • Light Client
            • Rust for Substrate
            • Introduction to Library
            • Architecture and Rust Libraries
            • File Architecture
            • Accounts, Addresses, and Keys
            • Transaction Format
            • Blockchain Randomness
          • FRAME
            • FRAME Pallets
            • FRAME Macros
            • Custom Pallets
            • Pallet Coupling
            • Origin
            • Events and Erros
            • Runtime Storage
            • State Transitions and Storage
            • SCALE Encoding
            • Weight and Fee
            • Runtime API
            • Runtime Development
          • Account
          • Address Format
          • Glossary
          • CLI
            • Archive
            • Memory Profiler
            • Node Template
            • sidecar
            • srtool
            • Subkey
            • subxt
            • try-runtime
            • tx-wrapper
          • Runtime Development
            • Basics
              • Configure Genesis State
              • Configure Runtime Constants
              • Customize a Chain Spec
              • Import a Pallet
              • Use Helper Function
            • Consensus Model
              • PoW
              • Create a Hybrid Node
            • Offchain Worker
              • Request Offchain HTTP
              • Offchain Indexing
              • Offchain Local Storage
            • Pallet Design
              • Create a Storage Structure
              • Implement Lockable Currency
              • Incorporate Randomness
              • Loose Coupling
              • Tight Coupling
            • Parachain Development
              • Add HRMP Channel
              • Add Paranodes
              • Connect to a Local Relay Chain
              • Convert a Solo Chain
              • Prepare to Launch
              • Select Collator
              • Upgrade a Parachain
            • Storage Migration
              • Basics
              • Trigger Migration
            • Test
              • Basics
              • Test a Transfer Transaction
            • Tools
              • Create a TxWrapper
              • Use Sidecar
              • try-runtime
              • Verify WASM
            • Weigths
              • Benchmark
              • Calculate Fees
              • Use Conditional Weights
              • Use Custom Weights
        • Build
          • Decide What to Build
          • Build Process
          • Determinisitc Runtime
          • Chain Spec
          • Genesis Configuration
          • Application Development
          • RPC
          • Troubleshoot Your Code
        • Tutorials
          • Install
            • Developer Tools
            • Linux
            • macOS
            • Rust Toolchain
            • Issues
            • Windows
          • Quick Start
            • Explore the Code
            • Modify Runtime
            • Start a Node
            • Substrate Basics
          • Build a Blockchain
            • Add Trusted Nodes
            • Authorize Specific Nodes
            • Build a Local Blockchain
            • Simulate Network
            • Upgrade a Running Network
          • Build Application Logic
            • Add a Pallet
            • Add Offchasin Workers
            • Publish Custom Pallets
            • Specify Origin for a Call
            • Use Macros in a Custom Pallet
          • Integrate with Tools
            • Access EVM Accounts
            • EVM Integration
            • Explore Sidecar Endpoints
            • Integrate a Light Client Node
          • Smart Contracts
            • Strategy
            • Build a Token Contract
            • Develop a Smart Contract
            • Prepare Your First Contract
            • Troubleshoot Smart Contracts
            • Use Maps for Storing Values
      • XCM
        • XCM
        • XCM Format
    • Service Chains
      • InfraDID
      • InfraEVM
      • URAuth(Universal Resource Auth)
    • DevOps
      • Build
      • Deploy
      • Monitoring
      • Runtime Upgrade
    • Tutorials
      • Basic
        • How to Interact with System Token
        • How To Pay Transaction Fee
        • How To Vote with TaaV
        • Hot to Get Validator Reward
      • Build
        • Build InfraRelayChain
        • Build Parachain
        • Open Message Passing Channels
        • Transfer Assets with XCM
      • Test
        • Benchmark
        • Check Runtime
        • Debug
        • Simulate Parachains
        • Unit Testing
      • Service Chains
        • Play with InfraDID
          • Build
          • Add Keys
          • Add Service Endpoint
          • Create InfraDID
        • Play with InfraEVM
          • Build
          • Deposit and Withdraw Token
          • Deploy ERC20 Contract
          • Deploy ERC721 Contract
          • Deploy ERC1155 Contract
  • Newnal Data Market
Powered by GitBook
On this page
  • Data Ownership Register
  • UR-Auth Tree
  • UR-Auth Tree Registration Rules
  • UR-Auth Document
  • Data Market
  • References
  1. InfraBlockchain
  2. Service Chains

URAuth(Universal Resource Auth)

It covers the overall contents of blockchain specialized in ownership of data, copyright information, data access, and transaction rule registration.

PreviousInfraEVMNextDevOps

Last updated 1 year ago

UR-Auth stands for Universal Resource Auth, a protocol that allows the ownership of web data and copyrighted tangible or intangible assets represented by URIs (Uniform Resource Identifiers) to be publicly registered on the internet using blockchain technology and Decentralized Identifiers (DID) technology. The URI, a widely-used identifier in web technology to uniquely identify logical and physical resources on and offline, registers its ownership on the blockchain using the DID of the URI's owner. This allows for a technical means for legitimate ownership claims when a large AI learns from it.

Data Ownership Register

The types of ownership registered on the UR-Auth blockchain can be broadly categorized into three areas:

  • Domain: Represents general domains like https://www.bc-labs.net.

  • Web Service Accounts: Represents accounts for a particular service like https://instagram.com/user.

  • Copyright of Data Files: Represents ownership of local data. This could include the address value (e.g. CID) of distributed storage like IPFS.

The registration process for ownership in each area is as follows:

Domain

  1. The domain owner creates their DID and sends a request_register_ownership transaction to the UR-Auth blockchain.

  2. UR-Auth blockchain generates a challenge value.

  3. The domain owner creates a *.json file containing domain verification information and uploads it to the root directory of that domain. For example, upload the challenge.json file to bc-labs.net/root.

  4. Oracle nodes consisting of trusted nodes download the *.json file and send a verify_challenge transaction to the UR-Auth blockchain.

Web Service Accounts

If ownership can be authenticated via OAuth:

Register the URI in the UR-Auth Tree by sending a claim_ownership transaction.

If OAuth authentication is not possible:

Copyright of Data Files and Datasets

UR-Auth Tree

Web page URLs and subpage URLs within a website can be represented as nodes in a Tree data structure on the blockchain. One UR-Auth Tree corresponds to one website domain and its data identified by URIs. Each node of the UR-Auth Tree stores a UR-Auth Document specifying ownership information, copyright information, data access rules, etc., for the URI.

UR-Auth Tree Registration Rules

  1. Registration of all sub-nodes in the UR-Auth Tree must be done by one of the owners of the upper node unless verified by an oracle.

  2. http or https is considered the same and should be omitted during registration. Any other protocol must be explicitly specified.

  3. www should be omitted, and any other prefixes must be specified during registration.

  4. The root node must be registered after verification by an oracle.

UR-Auth Document

#[derive(Encode, Decode, Clone, PartialEq, Debug, Eq, TypeInfo)]
pub struct URAuthDoc<Account> {
    pub id: DocId,
    pub created_at: u128,
    pub updated_at: u128,
    pub multi_owner_did: MultiDID<Account>,
    pub identity_info: Option<Vec<IdentityInfo>>,
    pub content_metadata: Option<ContentMetadata>,
    pub copyright_info: Option<CopyrightInfo>,
    pub access_rules: Option<Vec<AccessRule>>,
    pub asset: Option<MultiAsset>,
    pub data_source: Option<URI>,
    pub proofs: Option<Vec<Proof>>,
}

id

Identifier of the document.

created_at

Time the document was created.

updated_at

Time the document was updated.

multi_owner_did

List of owner DIDs for the document.

identity_info

List of identity information of the copyright holder.

contents_metadta

Information related to the content metadata associated with the URI.

access_rules

List of access rules for the URI.

asset

Information about tokenized datasets if the document is for a dataset.

data_source

URI information where the dataset is stored if the document is for a dataset.

proofs

List of electronic signatures for the document.

Data Market

Pre-packaged web datasets on the UR-Auth blockchain are also registered and traded in the Data Market, allowing web data consumers to pay legitimate data access costs to web data owners. This allows consumers to download and use pre-organized datasets for commercial AI machine learning, addressing data copyright issues.

Tokenized of Dataset and AI Model

Ownership of datasets or AI models created with a URI can be tokenized since ownership information is specified on UR-Auth blockchain. When a dataset is actually sold in the Data Market, rewards can be distributed according to the tokenized stake.

References

Dataset: Represents ownership of datasets created using URIs registered or not registered in the . The location value of the storage where the dataset is stored can be included.

Once the verification is completed by a sufficient number of oracle nodes (e.g. more than 60%), the domain is registered in the , and ownership registration is complete.

The user posts a certificate on their feed proving ownership of the account. Oracle nodes consisting of trusted nodes go through the verification process as described above. Once verified by a sufficient number of oracle nodes, register in the .

When registering a file or dataset, you receive a URI like urauth://file/{cid} or urauth://dataset/{cid}. Register the URI in the .

Each node of the has a UR-Auth Document recording information such as ownership, copyright, data access rules, etc., that apply to the URI and all its sub-URIs. The UR-Auth Document can only be modified by the owner DID of that node.

UR-Auth White Paper
UR-Auth Tree
UR-Auth Tree
UR-Auth Tree
UR-Auth Tree
UR-Auth Tree
Register Ownership
Ownership Claim on UR-Auth Tree
Data Market Tracking Ownership