;; title: ChainProtect
;; version:
;; summary:
;; description:
;; traits
;;
;; Define error codes
(define-constant ERR-NOT-AUTHORIZED (err u1000))
(define-constant ERR-INVALID-HASH-LENGTH (err u1001))
(define-constant ERR-HASH-ALL-ZEROS (err u1002))
(define-constant ERR-HASH-ALREADY-REGISTERED (err u1003))
(define-constant ERR-IP-NOT-FOUND (err u1004))
(define-constant ERR-INVALID-IP-ID (err u1005))
(define-constant ERR-IP-ID-OUT-OF-RANGE (err u1006))
(define-constant ERR-IP-EXPIRED (err u1007))
(define-constant ERR-INVALID-EXPIRATION (err u1008))
(define-constant ERR-NO-EXPIRATION-SET (err u1009))
;; Define the contract
(define-data-var owner principal tx-sender)
;; Define a map to store IP registrations
(define-map ip-registrations
{ ip-id: uint }
{
owner: principal,
timestamp: uint,
hash: (buff 32),
expiration: (optional uint),
}
)
;; Define a map to track registered hashes
(define-map registered-hashes
{ hash: (buff 32) }
{ ip-id: uint }
)
;; Define a counter for IP IDs
(define-data-var ip-counter uint u0)
;; Function to register new IP
(define-public (register-ip
(ip-hash (buff 32))
(expiration-block (optional uint))
)
(let (
(new-id (+ (var-get ip-counter) u1))
(current-block stacks-block-height)
)
;; Perform input validation
;; Perform input validation
(asserts! (is-eq (len ip-hash) u32) ERR-INVALID-HASH-LENGTH)
(asserts!
(not (is-eq ip-hash
0x0000000000000000000000000000000000000000000000000000000000000000
))
ERR-HASH-ALL-ZEROS
)
(asserts! (is-none (map-get? registered-hashes { hash: ip-hash }))
ERR-HASH-ALREADY-REGISTERED
)
;; Check expiration validity
(asserts!
(match expiration-block
expiration (> expiration current-block)
true
)
ERR-INVALID-EXPIRATION
)
;; Register the IP
(map-set ip-registrations { ip-id: new-id } {
owner: tx-sender,
timestamp: current-block,
hash: ip-hash,
expiration: expiration-block,
})
;; Track the registered hash
(map-set registered-hashes { hash: ip-hash } { ip-id: new-id })
(var-set ip-counter new-id)
(ok new-id)
)
)
;; Function to check IP ownership
(define-read-only (check-ip-ownership (ip-id uint))
(let ((ip-data (map-get? ip-registrations { ip-id: ip-id })))
(if (is-some ip-data)
(ok (get owner (unwrap-panic ip-data)))
ERR-IP-NOT-FOUND
)
)
)
;; Function to verify IP hash
(define-read-only (verify-ip-hash
(ip-id uint)
(hash-to-verify (buff 32))
)
(let ((ip-data (map-get? ip-registrations { ip-id: ip-id })))
(if (is-some ip-data)
(ok (is-eq (get hash (unwrap-panic ip-data)) hash-to-verify))
ERR-IP-NOT-FOUND
)
)
)
;; Function to transfer IP ownership
(define-public (transfer-ip
(ip-id uint)
(new-owner principal)
)
(let ((current-ip-counter (var-get ip-counter)))
;; Perform input validation
(asserts! (<= ip-id current-ip-counter) ERR-IP-ID-OUT-OF-RANGE)
(asserts! (> ip-id u0) ERR-INVALID-IP-ID)
(let ((ip-data (map-get? ip-registrations { ip-id: ip-id })))
(asserts! (is-some ip-data) ERR-IP-NOT-FOUND)
(let ((unwrapped-ip-data (unwrap-panic ip-data)))
(asserts! (is-eq tx-sender (get owner unwrapped-ip-data))
ERR-NOT-AUTHORIZED
)
(map-set ip-registrations { ip-id: ip-id }
(merge unwrapped-ip-data { owner: new-owner })
)
(ok true)
)
)
)
)
;; Function to check if a hash is already registered
(define-read-only (is-hash-registered (ip-hash (buff 32)))
(is-some (map-get? registered-hashes { hash: ip-hash }))
)
;; Smart Contract on Intellectual Property Protection with Expiration Date, Corrected Safety Checks, IP Update Functionality, Owner Verification, and Corrected Expiration Extension
;; function to extend IP registration
(define-public (extend-ip-registration
(ip-id uint)
(new-expiration uint)
)
(let (
(current-ip-counter (var-get ip-counter))
(current-block stacks-block-height)
)
;; Perform input validation
(asserts! (<= ip-id current-ip-counter) ERR-IP-ID-OUT-OF-RANGE)
(asserts! (> ip-id u0) ERR-INVALID-IP-ID)
(asserts! (> new-expiration current-block) ERR-INVALID-EXPIRATION)
(let ((ip-data (map-get? ip-registrations { ip-id: ip-id })))
(asserts! (is-some ip-data) ERR-IP-NOT-FOUND)
(let ((unwrapped-ip-data (unwrap-panic ip-data)))
(asserts! (is-eq tx-sender (get owner unwrapped-ip-data))
ERR-NOT-AUTHORIZED
)
(match (get expiration unwrapped-ip-data)
current-expiration (if (> new-expiration current-expiration)
(begin
(map-set ip-registrations { ip-id: ip-id }
(merge unwrapped-ip-data { expiration: (some new-expiration) })
)
(ok true)
)
ERR-INVALID-EXPIRATION
)
(begin
(map-set ip-registrations { ip-id: ip-id }
(merge unwrapped-ip-data { expiration: (some new-expiration) })
)
(ok true)
)
)
)
)
)
)
;; Function to update IP metadata (hash)
(define-public (update-ip-metadata
(ip-id uint)
(new-hash (buff 32))
)
(let ((current-ip-counter (var-get ip-counter)))
;; Perform input validation
(asserts! (<= ip-id current-ip-counter) ERR-IP-ID-OUT-OF-RANGE)
(asserts! (> ip-id u0) ERR-INVALID-IP-ID)
(asserts! (is-eq (len new-hash) u32) ERR-INVALID-HASH-LENGTH)
(asserts!
(not (is-eq new-hash
0x0000000000000000000000000000000000000000000000000000000000000000
))
ERR-HASH-ALL-ZEROS
)
(let ((ip-data (map-get? ip-registrations { ip-id: ip-id })))
(asserts! (is-some ip-data) ERR-IP-NOT-FOUND)
(let (
(unwrapped-ip-data (unwrap-panic ip-data))
(current-block stacks-block-height)
)
;; Check if the caller is the current owner
(asserts! (is-eq tx-sender (get owner unwrapped-ip-data))
ERR-NOT-AUTHORIZED
)
;; Check if the IP has not expired
(asserts!
(or
(is-none (get expiration unwrapped-ip-data))
(< current-block (unwrap-panic (get expiration unwrapped-ip-data)))
)
ERR-IP-EXPIRED
)
;; Remove the old hash from registered-hashes
(map-delete registered-hashes { hash: (get hash unwrapped-ip-data) })
;; Update the IP registration with the new hash
(map-set ip-registrations { ip-id: ip-id }
(merge unwrapped-ip-data { hash: new-hash })
)
;; Add the new hash to registered-hashes
(map-set registered-hashes { hash: new-hash } { ip-id: ip-id })
(ok true)
)
)
)
)