La rupture d'un brevet unique en "actions" NFT négociables transforme une propriété intellectuelle complexe en un actif liquide qui peut être acheté, vendu et géré par ses parties prenantes. En créant des jetons uniques qui représentent chacun une petite part d'une invention, les inventeurs peuvent obtenir un financement immédiat sans donner le contrôle à un seul backer. Ces jetons comprennent des métadonnées telles que les hashes de revendication, les identifiants décentralisés de l'inventeur et les blocs d'expiration, qui montrent clairement l'origine et les détails du brevet. De cette façon, les inventeurs peuvent atteindre un groupe mondial de petits investisseurs qui sont motivés à évaluer, à améliorer et à soutenir l'innovation Au lieu de quelques examinateurs examinant les soumissions en privé au cours de plusieurs années, les NFT de brevets fractionnels permettent à une communauté décentralisée de parier sur des jetons, d’examiner l’art précédent, de soumettre des réfutations et de voter sur la brevetabilité au cours d’une période d’examen fixée. Les scores de réputation et les seuils de quorum remplacent les attributions d’examinateurs fixes, permettant un consensus rapide ou la mise en évidence de domaines de désaccord à travers des transactions transparentes en chaîne. La découverte d’une invention La création d'une divulgation d'invention en tant que brevet fractionnel NFT commence par l'encodage des parties principales de votre demande de brevet, y compris ses revendications, les détails de l'inventeur et la date limite d'examen, en métadonnées en chaîne.En utilisant un contrat ERC-1155, chaque «partie» de brevet est montrée comme un solde fongible d'un ID de jeton unique. Explication du concept Dans ce modèle, un nouveau identifiant de jeton est créé pour chaque divulgation d'invention. Chaque identifiant de jeton comprend une structure qui enregistre le hash cryptographique du langage de réclamation du brevet, l'identifiant décentralisé de l'inventeur (DID) et un numéro de bloc d'expiration, après quoi aucun nouveau tour d'examen ne peut commencer. Syntaxe avec décomposition et explication 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, ""); } } Dans ce fragment, le La fonction prend quatre entrées. est le keccak256 hash du texte de la revendication du brevet. est un identifiant unique, tel que DID:example:1234, qui relie les enregistrements en chaîne à l'inventeur. définit un numéro de bloc après lequel les contrats de révision ne peuvent plus utiliser cette divulgation. décide combien de jetons fractionnels à créer pour cet ID. conserve les informations immuables pour une utilisation future. mintDisclosure claimHash inventorDID expiryBlock totalShares patents[tokenId] Expliquer les champs de métadonnées Chaque Les structures sont : Patent claimHash: Un bytes32 keccak256 hash assurant que l'enregistrement sur la chaîne correspond au langage de revendication hors chaîne sans exposer le texte entier. inventorDID: Un pointeur de chaîne sur l'identité décentralisée de l'inventeur, permettant une attribution non fiable. expiryBlock: Un numéro de bloc Ethereum de style Unix au-delà duquel la divulgation est considérée comme fermée pour de nouvelles rondes d'examen. Démonstration avec exemple Imaginez qu'Alice ait rédigé une demande provisoire et veut la fractionner en un million d'actions. const claimText = "A modular solar array with adaptive orientation…"; const claimHash = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(claimText)); Supposons qu’elle déploie Puis, après avoir obtenu son adresse, elle appelle : FractionalPatent await patentContract.mintDisclosure( claimHash, "did:example:alice123", 18_200_000, // expiryBlock ~ Ethereum block in six months 1_000_000 // total shares ); Cette transaction crée l'ID de jeton 1, enregistre les métadonnées d'Alice et amène 1 000 000 actions à son portefeuille.Ces actions peuvent désormais être transférées à des bailleurs de fonds, cotées sur des marchés, ou détenues dans un trésor du DAO pour financer le développement, tout en maintenant un enregistrement sécurisé et étanche sur la chaîne des détails essentiels de l'invention. Créer un cycle de crowd-review Dans un système de brevet fractionnel, le lancement d'un tour d'examen de la foule implique les détenteurs de jetons en tant qu'examinateurs actifs. Ils verrouillent une participation, examinent la divulgation et gagnent des récompenses pour trouver l'art préalable pertinent ou soutenir l'unicité du brevet. Ce processus d'examen est géré en chaîne par un contrat intelligent qui se lie à l'identifiant de jeton de la divulgation et fixe les règles pour la grève, les délais de rejet et les multiplicateurs de récompense pour encourager des révisions rapides et approfondies. Explication du concept Lorsqu'un tour de révision commence, le contrat de révision vérifie l'expirationBlock de la divulgation pour s'assurer que les délais sont antérieurs à ce bloc. Les détenteurs de jetons qui souhaitent rejoindre doivent transférer un montant déterminé d'actions de brevet dans le contrat de révision. En pariant, les réviseurs montrent qu'ils croient à leurs conclusions: s'ils trouvent un art préalable valide qui contredit la réclamation, ils obtiennent une récompense plus importante; s'ils ne peuvent pas soutenir leur défi, ils perdent leur participation. Syntaxe de contrat avec décomposition et explication 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; } } Ici, créé un nouveau cycle en spécifiant la divulgation Le minimum des actions nécessaires par participant, a dans les blocs, et a qui augmente les paiements pour les défis valides. La fonction verrouille les jetons et enregistre si l'examinateur conteste ou défend la réclamation. peut être appelé une fois que la fenêtre de rebut a pris fin; il calcule les récompenses, redistribue les mises et marque le tour comme réglé. startReview tokenId stakingAmount rebuttalWindow rewardMultiplier stakeAndSubmit settleRound Expliquer les drapeaux Chaque tour d'examen repose sur trois drapeaux économiques. Le montant de mise spécifie combien de jetons de brevets doivent être verrouillés pour participer, décourageant les soumissions inutiles. La fenêtre de rejet, mesurée en blocs Ethereum, fixe un délai strict pour les défis et les contre-arguments, assurant que le processus se termine rapidement. Le multiplicateur de récompense détermine le ratio entre le paiement total pour les défiants ou les défenseurs réussis et leur mise initiale, fournissant une forte incitation à découvrir un art préalable important ou à présenter une défense solide. Examen de la démonstration de workflow avec exemple Supposons que le brevet fractionnel d'Alice (ID de jeton 1) vient d'être créé et qu'il expire à 18 200 000 blocs. 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 ); Au bloc 18,195,000, Bob et Carol utilisent chacun Bob soumet un lien vers un article de pré-art montrant la technologie qui se recouvre, tandis que Carol, confiante dans sa nouveauté, utilise Ils ont tous les deux bloqué 100 actions dans le contrat. stakeAndSubmit(42, true) stakeAndSubmit(42, false) Une fois que le bloc 18 200 000 est atteint, tout le monde peut appeler Le contrat vérifie la citation préalable de Bob à travers un oracle hors chaîne ou un examen manuel. Ensuite, la logique en chaîne (ou un oracle de gouvernance) confirme que le défi de Bob est valide. Bob reçoit 150 actions (son action de 100 actions plus une récompense de 50 actions), Carol perd son action, et le titulaire du brevet réclame les 100 actions de Carol pour un pool de récompenses pour les tours futurs. settleRound(42) Licence et monétisation de brevets fractionnels NFT Une fois qu'une divulgation passe l'examen par les pairs, les détenteurs de jetons peuvent convertir leurs actions fractionnelles en revenus en cours en intégrant les splits de droits d'auteur et les conditions de licence directement dans les contrats intelligents. Au lieu de négocier des transactions de licence non claires, les inventeurs et les investisseurs utilisent un protocole transparent en chaîne qui transmet automatiquement des paiements aux détenteurs de jetons sur la base de termes préalablement convenus et inclut des mécanismes de rétractation en cas de défaut des licenciés. Explication du concept Dans cette configuration, un contrat de licence utilise l'ID de jeton de brevet et établit un plan de paiement, tel qu'un pourcentage de ventes futures ou une redevance fixe par utilisation, qui est envoyé régulièrement aux actionnaires. Les licenciés mettent de l'argent dans le contrat, qui le partage ensuite avec tous les détenteurs de jetons actuels. Si un titulaire de licence ne paie pas, une option de rétractation peut arrêter les paiements futurs jusqu'à ce que l'émission soit fixée, ou il peut commencer un vote pour annuler la licence. Cette méthode automatisée supprime les intermédiaires, aligne les intérêts des détenteurs de brevets et des licenciés et assure que chaque détenteur fractionnel obtient leur juste part en temps réel. Syntaxe Royalty Split avec décomposition et explication 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; } } Ici, définit une courbe de paiement linéaire, mesurée en Wei par action par seconde, permettant aux revenus de s'accumuler en continu au lieu de s'accumuler en sommes forfaitaires. La fonction calcule le temps passé depuis la dernière mise à jour, la multiplie par le nombre d'actions détenues dans l'escrow et transfère le montant correct aux détenteurs de jetons. flag permet à la gouvernance de suspendre la diffusion si le titulaire de la licence enfreint les termes. ratePerSecond streamPayments clawbackEnabled Démonstration de contrat de licence avec exemple Supposons qu'une société de logiciels, BetaSoft, décide de concéder une licence pour le brevet d'orientation solaire d'Alice (ID de jeton 1). Ils mettent 10 ETH dans le contrat de licence et fixent un taux de 1 gwei par action par seconde. Avec un million d'actions, cela signifie environ 0.0864 ETH en revenus totaux par jour. distribuer environ 0.0864 ETH à tous les détenteurs de jetons en fonction de leurs actions. Si BetaSoft ne fait pas un paiement à temps, le DAO peut utiliser arrêter les paiements jusqu'à ce qu'ils ajoutent plus de fonds. streamPayments(BetaSoft) triggerClawback(BetaSoft) Configurer des améliorations de gouvernance Au fil du temps, les détenteurs de jetons peuvent vouloir ajuster les paramètres de licence, tels que le changement des taux, l'ajout de nouvelles conditions de clawback ou l'inclusion de licences secondaires. Une fonctionnalité de mise à niveau de la gouvernance permet de proposer, voter et mettre en œuvre ces changements sans avoir à redéployer les contrats de base. Explication du concept Les mises à niveau commencent par des propositions en chaîne qui incluent l'adresse du contrat, le sélecteur de la fonction et de nouvelles valeurs de paramètre. Chaque proposition a un délai de temps, ce qui donne aux détenteurs de jetons le temps de revoir les changements. Mise à niveau de la syntaxe de proposition avec décomposition et explication 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; } } Dans ce cadre de gouvernance, le contrat cible et les données de fonction codées, puis définit un Les grandes parties prenantes peuvent recevoir des privilèges de veto hors chaîne ou via un oracle de réputation, tandis que les poids délégués ajustent l'influence de chaque vote en fonction des scores de réputation des parties prenantes. proposeUpgrade eta Mise à jour de la démonstration de vote avec exemple Imaginez que les détenteurs de jetons décident d'augmenter les revenus de BetaSoft de 1 gwei à 2 gwei. Le multisig du DAO appelle: ratePerSecond const data = licensingContract.interface.encodeFunctionData( "createLicense", [betaSoftAddress, 1, ethers.utils.parseUnits("2", "gwei"), false] ); await governanceContract.proposeUpgrade(licensingContract.address, data); Après le délai de deux jours, tout membre invoque : await governanceContract.executeUpgrade(proposalId); À ce moment-là, le taux de diffusion de BetaSoft double, et tous les détenteurs de jetons commencent immédiatement à gagner le double des revenus par seconde, tout cela sans avoir à déplacer des fonds ou à redéployer le contrat de licence. Pensées finales Les NFT de brevets fractionnels transforment la propriété intellectuelle en un actif dynamique et axé sur la communauté. En tokenisant une invention, vous pouvez rapidement collecter de l'argent, obtenir des commentaires rapides des pairs et automatiser la licence et le partage des revenus. Les tours de revue de la foule utilisent le pari pour trouver l'art antérieur ou renforcer les revendications de brevets, tandis que les modules de gouvernance permettent aux détenteurs de jetons de décider des mises à niveau et des conditions de licence. Les tribunaux et les bureaux de brevets accepteront-ils les hashes en chaîne et les pistes d’audit basées sur des jetons comme preuves?Comment le système peut-il arrêter le «spam pré-art» et les conflits d’intérêts entre les détenteurs de jetons?Résoudre ces problèmes nécessitera le travail d’équipe entre les experts technologiques, les professionnels du droit et les organismes de normalisation. Pour ceux qui sont intéressés, l’Organisation mondiale de la propriété intellectuelle (OMPI) fournit des recherches sur les examens rapides de brevets et les normes de preuves numériques. Les bibliothèques open-source telles que l’ERC-1155 d’OpenZeppelin et les plates-formes telles que Kleros offrent des outils.
