NFTs สามารถตรวจสอบนวัตกรรมได้เร็วกว่า USPTO

การทําลายสิทธิบัตรเดียวเป็น "หุ้น" ของ NFT ที่สามารถเทรดได้ทําให้ทรัพย์สินทางปัญญาที่ซับซ้อนกลายเป็นสินทรัพย์ที่สามารถซื้อขายและจัดการได้โดยผู้มีส่วนร่วม โดยการสร้าง tokens เฉพาะซึ่งแต่ละตัวเป็นส่วนหนึ่งเล็ก ๆ ของการประดิษฐ์นักประดิษฐ์สามารถได้รับเงินทุนได้ทันทีโดยไม่ให้การควบคุมให้กับผู้สนับสนุนคนหนึ่ง แท็กเหล่านี้รวมถึงข้อมูลเมตาเช่น hashes การเรียกร้อง identifier decentralized นักประดิษฐ์และบล็อกการหมดอายุซึ่งแสดงให้เห็นถึงแหล่งกําเนิดและรายละเอียดของสิทธิบัตร ด้วยวิธีนี้นักประดิษฐ์สามารถเข้าถึงกลุ่มผู้ลงทุนขนาดเล็กทั่วโลกซึ่งมีแรงจูงใจในการประเมินปรับปรุงและสนับสนุนนวัตกรรมตั้งแต่เริ่มต้น

การประเมินกลุ่มโดยใช้การปกครองที่ขึ้นอยู่กับโทเค็นแตกต่างจากรูปแบบการประเมินแบบปิดแบบดั้งเดิมของสํานักงานสิทธิบัตรและเครื่องหมายการค้าของสหรัฐอเมริกา แทนที่นักประเมินไม่กี่คนที่ประเมินการประเมินในส่วนตัวเป็นเวลาหลายปี NFTs สิทธิบัตรแบบแยกส่วนช่วยให้ชุมชนที่กระจายการประเมินการประเมินการประเมินก่อนการประเมินการประเมินการประเมินการประเมินและการประเมินการประเมินการประเมินภายในระยะเวลาการประเมินที่กําหนดคะแนนชื่อเสียงและขีด จํากัด จะแทนที่การประเมินการประเมินที่คงที่ช่วยให้สามารถประเมินความเห็นด้วยกันอย่างรวดเร็วหรือเน้นพื้นที่ของความแตกต่างผ่านการทําธุรกรรมแบบโปร่งใส กระบวนการเปิดนี้ไม่เพียง แต่เร่งการประเม

Tokenize A Invention การเปิดเผย

การสร้างการเปิดเผยการประดิษฐ์ในฐานะสิทธิบัตรส่วนแบ่ง NFT เริ่มต้นโดยการเข้ารหัสส่วนหลักของใบสมัครสิทธิบัตรของคุณรวมถึงข้อเรียกร้องของนักประดิษฐ์รายละเอียดและระยะเวลาการตรวจสอบลงในข้อมูลเมตาของโซ่ โดยใช้สัญญา ERC-1155 แต่ละสิทธิบัตร "share" จะแสดงให้เห็นว่าเป็นสมดุลที่สามารถเปลี่ยนได้ของ ID token ที่เป็นเอกลักษณ์ บุคคลที่ถือ ID token เหล่านี้ด้วยกันเป็นเจ้าของการเปิดเผยและมีส่วนร่วมในการตรวจสอบและการตัดสินใจในการอนุญาต

คําอธิบายแนวคิด

ในโมเดลนี้ ID โค้กใหม่จะถูกสร้างขึ้นสําหรับแต่ละการเปิดเผยการประดิษฐ์ ID โค้กแต่ละตัวรวมถึงโครงสร้างที่บันทึกฮับการเข้ารหัสของภาษาการเรียกร้องสิทธิบัตร ID decentralized ของนักประดิษฐ์ (DID) และหมายเลขบล็อกที่หมดอายุหลังจากนั้นไม่สามารถเริ่มต้นรอบการตรวจสอบใหม่ได้ นักลงทุนซื้อสมดุลของ โค้กเพื่อเงินทุนการประดิษฐ์และได้รับรางวัลสําหรับการเข้าร่วมในการตรวจสอบร่วมกัน เนื่องจากข้อมูลทั้งหมดรวมถึงแหล่งกําเนิดของ IP และขีด จํากัด เวลาถูกเก็บไว้ในโซ่ไม่มีบุคคลที่ศูนย์กลางสามารถเปลี่ยนแปลงรายละเอียดของการเปิดเผยหรือ จํากัด การเข้าถึงกระบวนการตรวจสอบ

Minting Syntax กับ Breakdown และ คําอธิบาย

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract FractionalPatent is ERC1155, Ownable {
    struct Patent {
        bytes32 claimHash;
        string inventorDID;
        uint256 expiryBlock;
    }

    mapping(uint256 => Patent) public patents;
    uint256 private nextId = 1;

    constructor(string memory uri_) ERC1155(uri_) {}

    function mintDisclosure(
        bytes32 claimHash,
        string calldata inventorDID,
        uint256 expiryBlock,
        uint256 totalShares
    ) external onlyOwner returns (uint256 tokenId) {
        tokenId = nextId++;
        patents[tokenId] = Patent(claimHash, inventorDID, expiryBlock);
        _mint(msg.sender, tokenId, totalShares, "");
    }
}

ใน snippet นี้, themintDisclosureฟังก์ชั่นใช้สี่อินพุตclaimHashเป็น keccak256 แฮชของข้อความการเรียกร้องสิทธิบัตรinventorDIDเป็นตัวระบุที่ไม่ซ้ํากันเช่น DID:example:1234 ซึ่งเชื่อมต่อบันทึกในโซ่กับผู้สร้างexpiryBlockตั้งหมายเลขบล็อกหลังจากที่สัญญาการตรวจสอบไม่สามารถใช้การเปิดเผยนี้ได้อีกต่อไป สุดท้ายtotalSharesกําหนดจํานวน tokens ส่วนที่จะสร้างสําหรับ ID เหล่านี้ การทําแผนที่patents[tokenId]เก็บข้อมูลที่ไม่สามารถเปลี่ยนแปลงได้สําหรับการใช้งานในอนาคต

คําอธิบายฟิลด์เมตาเดท

ทุกคนPatentStruct เก็บ:

• claimHash: A bytes32 keccak256 แฮชให้แน่ใจว่าบันทึกในโซ่ตรงกับภาษาการเรียกร้องนอกโซ่โดยไม่ต้องเปิดเผยข้อความเต็มรูปแบบ
• inventorDID: ตัวชี้แจงสี่เหลี่ยมที่ระบุตัวตนแบบแยกส่วนของนักประดิษฐ์ซึ่งช่วยให้การกําหนดค่าที่ไม่น่าเชื่อถือได้
• expiryBlock: หมายเลขบล็อก Ethereum แบบ Unix ขึ้นไปกว่าที่การเปิดเผยจะถือว่าปิดสําหรับการตรวจสอบใหม่

การแสดงนิทรรศการด้วยตัวอย่าง

ลองจินตนาการ Alice ได้วาดใบสมัครชั่วคราวและต้องการแบ่งเป็นหนึ่งล้านหุ้น เธอคํานวณครั้งแรก:

const claimText = "A modular solar array with adaptive orientation…";
const claimHash = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(claimText));

การคาดเดาว่าเธอใช้FractionalPatentและได้รับที่อยู่ของเธอแล้วเธอโทรหา:

await patentContract.mintDisclosure(
  claimHash,
  "did:example:alice123",
  18_200_000,            // expiryBlock ~ Ethereum block in six months
  1_000_000              // total shares
);

การทําธุรกรรมนี้สร้าง ID token 1, บันทึกข้อมูลเมตาของ Alice และเหรียญ 1,000,000 หุ้นไปยังกระเป๋าสตางค์ของเธอ ตอนนี้หุ้นเหล่านี้สามารถโอนไปยังผู้สนับสนุนลงทะเบียนในตลาดหรือเก็บไว้ในสกุลเงินของ DAO เพื่อเงินทุนการพัฒนาทั้งหมดในขณะที่รักษาบันทึกที่ปลอดภัยและป้องกันการล้มเหลวในโซ่ของรายละเอียดที่สําคัญของประดิษฐ์

เปิดรอบ Crowd-Review

ในระบบสิทธิบัตรส่วนแบ่งเริ่มต้นรอบการตรวจสอบกลุ่มจะทําให้ผู้ถือโทเค็นมีส่วนร่วมในฐานะผู้ตรวจสอบที่ใช้งาน พวกเขาล็อคหุ้นตรวจสอบการเปิดเผยและได้รับรางวัลสําหรับการค้นพบศิลปะก่อนหน้านี้ที่เกี่ยวข้องหรือสนับสนุนความโดดเด่นของสิทธิบัตร กระบวนการตรวจสอบนี้ได้รับการจัดการในโซ่โดยสัญญาอัจฉริยะที่เชื่อมโยงกับ ID โค้กของการเปิดเผยและกําหนดกฎสําหรับการลงโทษการปฏิเสธช่วงเวลาและตัวบ่งชี้รางวัลเพื่อส่งเสริมการตรวจสอบอย่างรวดเร็วและละเอียด

คําอธิบายแนวคิด

เมื่อรอบการตรวจสอบเริ่มต้นการตรวจสอบสัญญาตรวจสอบ expiryBlock จากการเปิดเผยเพื่อให้แน่ใจว่าระยะเวลาที่กําหนดไว้ก่อนบล็อกนี้ ผู้ถือจดหมายที่ต้องการเข้าร่วมจะต้องโอนจํานวนเงินที่กําหนดไว้ของหุ้นสิทธิบัตรไปยังสัญญาการตรวจสอบ โดยการเดิมพันผู้ตรวจสอบแสดงให้เห็นว่าพวกเขาเชื่อในค้นพบของพวกเขา: หากพวกเขาพบศิลปะก่อนหน้านี้ที่ถูกต้องซึ่งปฏิเสธข้อร้องเรียนพวกเขาจะได้รับรางวัลที่ยิ่งใหญ่กว่า หากพวกเขาไม่สามารถสนับสนุนความท้าทายของพวกเขาพวกเขาพวกเขาจะสูญเสียส่วนแบ่งของพวกเขา เมื่อระยะเวลาของการปฏิเสธสิ้นสุดสัญญาจะคํานวณการเดิมพันโดยอัตโนมัติและให้รางวัลแก่นักปฏิเสธที่ประสบความสําเร็จและนักป้องกันที่ซื่อสัตย์บนพื้นฐานของระบบการจ่ายเงินที่ชัดเจน

รีวิว Syntax Contract พร้อมการแบ่งปันและคําอธิบาย

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";

contract CrowdReview {
    struct Round {
        uint256 tokenId;
        uint256 stakingAmount;
        uint256 rebuttalEndBlock;
        uint8 rewardMultiplier; // e.g., 150 for 1.5× payout
        bool settled;
    }

    mapping(uint256 => Round) public rounds;
    IERC1155 public patentToken;

    constructor(address tokenAddress) {
        patentToken = IERC1155(tokenAddress);
    }

    function startReview(
        uint256 roundId,
        uint256 tokenId,
        uint256 stakingAmount,
        uint256 rebuttalWindow,
        uint8 rewardMultiplier
    ) external {
        uint256 current = block.number;
        rounds[roundId] = Round({
            tokenId: tokenId,
            stakingAmount: stakingAmount,
            rebuttalEndBlock: current + rebuttalWindow,
            rewardMultiplier: rewardMultiplier,
            settled: false
        });
    }

    function stakeAndSubmit(uint256 roundId, bool challengesClaim) external {
        Round storage r = rounds[roundId];
        require(block.number < r.rebuttalEndBlock, "Review closed");
        patentToken.safeTransferFrom(msg.sender, address(this), r.tokenId, r.stakingAmount, "");
        // Record submission choice—challenge or defend
    }

    function settleRound(uint256 roundId) external {
        Round storage r = rounds[roundId];
        require(block.number >= r.rebuttalEndBlock && !r.settled, "Cannot settle");
        // Pseudocode: determine winners, calculate payouts
        // payout = stakingAmount * rewardMultiplier / 100
        r.settled = true;
    }
}

นี่startReviewสร้างรอบใหม่โดยการระบุการเปิดเผยข้อมูลtokenIdและขั้นต่ําstakingAmountของส่วนแบ่งที่จําเป็นต่อผู้เข้าร่วม arebuttalWindowในบล็อกและ arewardMultiplierซึ่งเพิ่มการจ่ายเงินสําหรับความท้าทายที่ถูกต้องstakeAndSubmitฟังก์ชั่นล็อค tokens และบันทึกว่าผู้ตรวจสอบจะท้าทายหรือปกป้องข้อเรียกร้อง ในที่สุดsettleRoundสามารถเรียกได้เมื่อหน้าต่างการปฏิเสธเสร็จสิ้น; มันคํานวณรางวัลการกระจายการเดิมพันและทําเครื่องหมายรอบเป็นเสร็จสิ้น

คําอธิบายธง

รอบการตรวจสอบแต่ละครั้งขึ้นอยู่กับสามธงทางเศรษฐกิจ จํานวนการเดิมพันระบุจํานวนจดหมายสิทธิบัตรที่ต้องถูกล็อคเพื่อเข้าร่วมซึ่งจะขัดขวางการส่งมอบที่ไม่จําเป็น หน้าต่างการเดิมพันที่วัดในบล็อก Ethereum จะกําหนดระยะเวลาที่เข้มงวดสําหรับการท้าทายและข้อต่อเพื่อให้แน่ใจว่ากระบวนการเสร็จสมบูรณ์ได้อย่างรวดเร็ว ตัวบ่งชี้รางวัลกําหนดอัตราส่วนระหว่างการจ่ายเงินทั้งหมดสําหรับผู้ท้าทายหรือผู้ปกป้องที่ประสบความสําเร็จและการเดิมพันเดิมของพวกเขาให้แรงจูงใจที่แข็งแกร่งในการค้นพบศิลปะก่อนหน้านี้ที่สําคัญหรือนําเสนอการป้องกันที่แข็งแกร่ง

ตรวจสอบการแสดงผลกระบวนการทํางานด้วยตัวอย่าง

แสดงให้เห็นว่าสิทธิบัตรส่วนบุคคลของ Alice (Token ID 1) ได้ถูกทําลายและจะหมดอายุในบล็อก 18,200,000 เพื่อเริ่มการตรวจสอบอย่างรวดเร็วเธอโทรหา:

await reviewContract.startReview(
  42,           // arbitrary round ID
  1,            // tokenId referencing Alice’s disclosure
  100,          // stakingAmount: 100 shares per reviewer
  5000,         // rebuttalWindow: ~5000 blocks (~19 hours)
  150           // rewardMultiplier: 1.5× payout for winners
);

ที่บล็อก 18,195,000 บ๊อบและแคโรลแต่ละใช้stakeAndSubmit(42, true)เพื่อท้าทายสิทธิบัตร บ๊อบส่งลิงก์ไปยังกระดาษก่อนศิลปะแสดงเทคโนโลยีที่ซับซ้อนในขณะที่แคโรลมั่นใจในความแปลกใหม่ของมันใช้stakeAndSubmit(42, false)เพื่อปกป้องมัน ทั้งสองล็อค 100 หุ้นลงในสัญญา

เมื่อบล็อก 18,200,000 ได้รับการเข้าถึงทุกคนสามารถโทรหาsettleRound(42)ข้อตกลงตรวจสอบการอ้างอิงก่อนหน้าของบ๊อบผ่านการอ้างอิงภายนอกโซ่หรือการตรวจสอบด้วยตนเอง จากนั้นกลยุทธ์ในโซ่ (หรือการอ้างอิงการปกครอง) จะยืนยันความท้าทายของบ๊อบว่าเป็นที่ถูกต้อง บ๊อบได้รับ 150 หุ้นกลับ (หุ้น 100 หุ้นของเขาและรางวัล 50 หุ้น) คาโรลจะสูญเสียหุ้นของเธอและเจ้าของสิทธิบัตรจะเรียกร้องหุ้น 100 ของคอลเลกชันของคอลเลกชันสําหรับรอบรางวัลในอนาคต วงจรทั้งหมดตั้งแต่เริ่มต้นจนถึงการชําระเงินเสร็จสิ้นในเวลาไม่กี่วันแสดงให้เห็นว่าการตรวจสอบโดยกลุ่มโดยใช้ token จะเร่งกระบวนการตรวจสอบเมื่อเทียบกับระยะเวลาหลายปีของ USPTO

ใบอนุญาตและทํากําไรสิทธิบัตรส่วนแบ่ง NFTs

เมื่อการเปิดเผยผ่านการตรวจสอบโดยคู่ค้าผู้ถือโทเค็นสามารถแปลงหุ้นส่วนของพวกเขาเป็นรายได้ต่อเนื่องโดยการบูรณาการการกระจายค่าธรรมเนียมและเงื่อนไขการอนุญาตโดยตรงลงในสัญญาสมาร์ท แทนที่จะเจรจาข้อตกลงการอนุญาตที่ไม่ชัดเจนและครั้งเดียวนักประดิษฐ์และนักลงทุนใช้โปรโตคอลในโซ่ที่โปร่งใสซึ่งอัตโนมัติไหลการชําระเงินไปยังผู้ถือโทเค็นตามเงื่อนไขที่ตกลงมาล่วงหน้าและรวมถึงกลไกการคืนเงินหากผู้ได้รับอนุญาตไม่ได้รับอนุญาต

คําอธิบายแนวคิด

ในการตั้งค่านี้สัญญาอนุญาตใช้ ID แท็กสิทธิบัตรและตั้งแผนการชําระเงินเช่นเปอร์เซ็นต์ของการขายในอนาคตหรือค่าธรรมเนียมคงที่ต่อการใช้งานซึ่งจะถูกส่งไปยังผู้ถือหุ้นอย่างสม่ําเสมอ ผู้รับอนุญาตใส่เงินลงในสัญญาซึ่งจากนั้นแบ่งปันกับผู้ถือแท็กทั้งหมดในปัจจุบัน หากผู้รับอนุญาตไม่ได้ชําระเงินตัวเลือกการคืนเงินสามารถหยุดการชําระเงินในอนาคตจนกว่าปัญหาจะถูกแก้ไขหรือสามารถเริ่มการลงคะแนนเพื่อยกเลิกใบอนุญาต วิธีอัตโนมัตินี้จะตัดตัวกลางออกให้สอดคล้องกับความสนใจของผู้ถือสิทธิบัตรและผู้รับอนุญาตและให้แน่ใจว่าผู้ถือส่วนแบ่งแต่ละคนได้รับส่วนแบ่งที่สมเหตุสมผลในเวลาจริง

Royalty Split Syntax พร้อมการแบ่งปันและคําอธิบาย

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract PatentLicensing is ReentrancyGuard {
    IERC1155 public patentToken;

    struct License {
        uint256 tokenId;
        uint256 ratePerSecond;       // Wei streamed per share per second
        uint256 lastUpdate;          // Timestamp of last distribution
        bool clawbackEnabled;        // Pauses streaming on default
    }

    mapping(address => License) public licenses;

    constructor(address _token) {
        patentToken = IERC1155(_token);
    }

    function createLicense(
        address licensee,
        uint256 tokenId,
        uint256 ratePerSecond,
        bool clawbackEnabled
    ) external {
        licenses[licensee] = License({
            tokenId: tokenId,
            ratePerSecond: ratePerSecond,
            lastUpdate: block.timestamp,
            clawbackEnabled: clawbackEnabled
        });
    }

    function streamPayments(address licensee) external nonReentrant {
        License storage lic = licenses[licensee];
        uint256 elapsed = block.timestamp - lic.lastUpdate;
        uint256 totalShares = patentToken.balanceOf(address(this), lic.tokenId);
        uint256 payout = elapsed * lic.ratePerSecond * totalShares;
        lic.lastUpdate = block.timestamp;
        payable(licensee).transfer(payout);
    }

    function triggerClawback(address licensee) external {
        licenses[licensee].clawbackEnabled = true;
    }
}

นี่ratePerSecondกําหนดเส้นโค้งการจ่ายเงินเชิงเส้นที่วัดใน Wei ต่อหุ้นต่อวินาทีช่วยให้รายได้สะสมอย่างต่อเนื่องแทนในจํานวนเงินเดี่ยวstreamPaymentsฟังก์ชั่นคํานวณเวลาที่ผ่านไปตั้งแต่การอัปเดตครั้งล่าสุด multiplies โดยจํานวนหุ้นที่ถืออยู่ใน escrow และโอนจํานวนเงินที่ถูกต้องไปยังผู้ถือ tokenclawbackEnabledอนุญาตให้การจัดการหยุดการสตรีมมิ่งหากผู้ได้รับอนุญาตละเมิดเงื่อนไข

ใบอนุญาตการทําธุรกรรมตัวอย่างด้วยตัวอย่าง

แสดงให้เห็นว่า บริษัท ซอฟต์แวร์ BetaSoft จะตัดสินใจให้ใบอนุญาตสิทธิบัตรการตั้งค่าพลังงานแสงอาทิตย์ของ Alice (Token ID 1) พวกเขาใส่ 10 ETH ในสัญญาใบอนุญาตและตั้งค่าอัตราของ 1 gwei ต่อหุ้นต่อวินาที ด้วยหุ้นหนึ่งล้านซึ่งหมายความว่าประมาณ 0.0864 ETH ในรายได้รวมต่อวัน ทุก 24 ชั่วโมงสัญญาของ Alice สามารถใช้streamPayments(BetaSoft)เพื่อกระจายประมาณ 0.0864 ETH ไปยังผู้ถือ token ทั้งหมดขึ้นอยู่กับหุ้นของพวกเขา หาก BetaSoft ไม่ทําการชําระเงินในเวลา DAO สามารถใช้triggerClawback(BetaSoft)ปิดการชําระเงินจนกว่าจะเพิ่มเงินทุนมากขึ้น

การกําหนดค่าการปรับปรุงการจัดการ

เมื่อเวลาผ่านไปผู้ถือโทเค็นอาจต้องการปรับพารามิเตอร์การอนุญาตเช่นการเปลี่ยนแปลงอัตราการเพิ่มเงื่อนไขการคืนเงินใหม่หรือรวมใบอนุญาตที่สอง คุณลักษณะการอัพเกรดการปกครองช่วยให้คุณสามารถนําเสนอการลงคะแนนและนําไปใช้การเปลี่ยนแปลงเหล่านี้ได้โดยไม่จําเป็นต้องใช้สัญญาหลักใหม่

คําอธิบายแนวคิด

การอัพเกรดเริ่มต้นด้วยข้อเสนอในห่วงโซ่ซึ่งรวมถึงที่อยู่สัญญาตัวเลือกฟังก์ชั่นและค่าพารามิเตอร์ใหม่ แต่ละข้อเสนอมีช่วงเวลาที่ล่าช้าให้ผู้ถือโทเค็นเวลาในการตรวจสอบการเปลี่ยนแปลง ผู้มีส่วนร่วมที่มีชื่อเสียงสูงสามารถมีสิทธิห้ามและอนุญาตให้ผู้ลงทุนขนาดใหญ่ให้อํานาจการลงคะแนนให้กับผู้เชี่ยวชาญ

อัปเดตข้อเสนอซินเท็กซ์ด้วยการแบ่งปันและคําอธิบาย

pragma solidity ^0.8.0;

contract Governance {
    struct Proposal {
        address target;
        bytes data;           // Encoded function call
        uint256 eta;          // Execution timestamp (after timelock)
        bool executed;
    }

    uint256 public timelockDelay = 2 days;
    mapping(uint256 => Proposal) public proposals;
    uint256 private nextProposalId;

    function proposeUpgrade(
        address target,
        bytes calldata data
    ) external returns (uint256 proposalId) {
        proposalId = nextProposalId++;
        proposals[proposalId] = Proposal({
            target: target,
            data: data,
            eta: block.timestamp + timelockDelay,
            executed: false
        });
    }

    function executeUpgrade(uint256 proposalId) external {
        Proposal storage p = proposals[proposalId];
        require(block.timestamp >= p.eta, "Timelock not expired");
        require(!p.executed, "Already executed");
        (bool success, ) = p.target.call(p.data);
        require(success, "Upgrade failed");
        p.executed = true;
    }
}

ในสัญญาการจัดการนี้proposeUpgradeแพคเกจสัญญาเป้าหมายและข้อมูลฟังก์ชั่นที่เข้ารหัสแล้วตั้งค่าetaซึ่งบังคับใช้ความล่าช้าในระยะเวลา ผู้มีส่วนร่วมขนาดใหญ่สามารถได้รับสิทธิยกเว้นภายนอกโซ่หรือผ่านคําอธิษฐานชื่อเสียงในขณะที่น้ําหนักผู้ส่งมอบปรับผลกระทบของแต่ละการลงคะแนนชื่อเสียง

อัปเดตการแสดงผลการลงคะแนนด้วยตัวอย่าง

จินตนาการว่าผู้ถือ token จะตัดสินใจที่จะเพิ่ม BetaSoftratePerSecondจาก 1 gwei ถึง 2 gwei. การเรียกร้อง multisig ของ DAO คือ:

const data = licensingContract.interface.encodeFunctionData(
  "createLicense",
  [betaSoftAddress, 1, ethers.utils.parseUnits("2", "gwei"), false]
);
await governanceContract.proposeUpgrade(licensingContract.address, data);

หลังจากระยะเวลาสองวันสมาชิกใด ๆ จะเรียกร้อง:

await governanceContract.executeUpgrade(proposalId);

ในช่วงเวลานั้นอัตราการสตรีมมิ่งของ BetaSoft คู่ขึ้นและผู้ถือ token ทั้งหมดเริ่มสร้างรายได้สองเท่าต่อวินาทีโดยไม่จําเป็นต้องย้ายเงินหรือใช้สัญญาใบอนุญาตใหม่

ความคิดสุดท้าย

NFTs ที่ได้รับสิทธิบัตรส่วนแบ่งเปลี่ยนทรัพย์สินทางปัญญาเป็นสินทรัพย์ที่มีชีวิตชีวาและมุ่งเน้นไปที่ชุมชน โดยการทําเครื่องหมายการประดิษฐ์คุณสามารถรวบรวมเงินได้อย่างรวดเร็วรับความคิดเห็นจากเพื่อนร่วมงานได้อย่างรวดเร็วและอัตโนมัติการให้ใบอนุญาตและการแบ่งปันรายได้ รอบการตรวจสอบจํานวนมากใช้การพนันเพื่อค้นหาศิลปะก่อนหน้านี้หรือทําให้การเรียกร้องสิทธิบัตรแข็งแกร่งขึ้นในขณะที่โมดูลการปกครองช่วยให้ผู้ถือเครื่องหมายตัดสินใจเกี่ยวกับการอัพเกรดและเงื่อนไขการอนุญาต

แต่ยังคงมีคําถาม คําถามที่พบบ่อย: จะศาลและสํานักงานสิทธิบัตรยอมรับ hashes บนโซ่และติดตามการตรวจสอบบนพื้นฐานของโทเค็นเป็นหลักฐานหรือไม่? ระบบสามารถหยุด "สแปมอาร์ตก่อน" และความขัดแย้งความสนใจระหว่างผู้ถือโทเค็นได้อย่างไร? การแก้ปัญหาเหล่านี้จะต้องทํางานร่วมทีมระหว่างผู้เชี่ยวชาญด้านเทคนิคผู้เชี่ยวชาญด้านกฎหมายและองค์กรมาตรฐาน

สําหรับผู้ที่สนใจ WIPO ให้การวิจัยเกี่ยวกับการสอบสิทธิบัตรอย่างรวดเร็วและมาตรฐานการพิสูจน์ดิจิตอล แคสติ๊กเกอร์แหล่งที่มาเปิดเช่น OpenZeppelin's ERC-1155 และแพลตฟอร์มเช่น Kleros ให้เครื่องมือ การทดสอบครั้งแรกโดย IPwe และโปรโตคอล Baseline คือการทดสอบจดทะเบียนสิทธิบัตรบนโซ่และสินทรัพย์ IP ที่ถูกทําเครื่องหมาย ความพยายามเหล่านี้แสดงให้เห็นถึงอนาคตที่ NFTs จะปรับปรุงการประดิษฐ์และการอนุญาต