Os IP-NFTs são tokens não fungíveis que representam propriedade intelectual (IP ou intellectual property) legalmente vinculada que está sendo usada atualmente na ciência descentralizada (DeSci). Aqui, descrevemos seu funcionamento interno e como você pode utilizar seu esquema de metadados, camada de dados e métodos de contrato inteligente para criar sua própria representação de propriedade intelectual em blockchains baseadas em EVM. Para começar com a ideia geral e o escopo dos IP-NFTs, recomendamos primeiro ler nossa visão sobre o futuro da pesquisa e nossa introdução não técnica em cunhagens de IP-NFT para usuários.
Tokens em poucas palavras
Tokens não fungíveis ( NFTs ) são ativos baseados em contratos inteligentes que associam um identificador de token exclusivo ao endereço blockchain de seu respectivo proprietário. Seus contratos inteligentes subjacentes definem regras sobre como eles são cunhados (trazidos à existência), transferidos ou queimados (destruídos). Ele também pode restringir sua capacidade de ser transferido ou oferecer recursos desbloqueados para detentores de tokens individuais. Duas implementações padrão de NFT surgiram no ecossistema Ethereum até agora: o clássico ERC-721 define uma relação de propriedade única entre IDs de ativos e seus proprietários. Ele adiciona um padrão rudimentar de metadados ao expor um método tokenURI(uint) que gera um link individual (ou comum) para os metadados de cada id de ativo. O padrão multitoken ERC-1155, ligeiramente mais recente, não é totalmente compatível com o ERC-721, mas também permite que os usuários criem e distribuam vários tokens do mesmo “tipo”, não muito diferente de várias instâncias de uma joia rara - mas não única. Um tipo de token ERC-1155 com apenas uma instância representa efetivamente os ativos da mesma forma que o ERC-721.
Quando se trata de propriedade de ativos com base na Web3, esses dois ERCs são o padrão ouro, são suportados por todos os principais mercados e inúmeros projetos construíram um ecossistema em torno deles para negociação, bloqueio, votação e fracionamento. Os NFTs também podem representar ativos do mundo real e valores de marca. Estamos usando-os para representar um aspecto de propriedade para a classe de ativos mais abstrata de todas: a propriedade intelectual.
Tokenização de propriedade intelectual com NFTs
Embora não haja uma resposta final sobre como a propriedade intelectual do mundo real pode ser representada por um ativo baseado em blockchain, os IP-NFTs referem-se a acordos de papel juridicamente vinculativos que são anexados aos seus metadados como cópias digitais (PDFs). Esses acordos denominam a entidade detentora de uma propriedade intelectual como titular de um NFT sobre uma determinada coleção. O proprietário atual do NFT pode provar legalmente que detém os direitos de propriedade intelectual baixando e verificando os documentos legais anexados em sua própria máquina. No entanto, nem todos os acordos devem ser visíveis ao público em geral. Portanto, esses documentos devem ser criptografados de forma que apenas o atual detentor do NFT ou os usuários a quem eles concederam acesso de leitura possam descriptografá-los - um aspecto também conhecido como conteúdo "token gated".
Uma vez representado como um NFT, toda a mecânica de token conhecida torna-se operacional na propriedade intelectual: ele pode ser negociado em mercados abertos, sendo licitado e solicitado, pode ser fracionado para representar direitos de propriedade distribuídos ou até mesmo bloqueado em sintetizadores de token para cultivar tokens que representam direitos de voto em outros protocolos. Não é o protocolo IP-NFT em si que desencadeia essas possibilidades, é o ecossistema NFT que é desbloqueado depois de cunhado por seus proprietários iniciais.
Fundamentos Técnicos
IP-NFTs são ativos ERC-1155 em blockchains Ethereum. Seu contrato de coleta relevante é implantado na rede principal e na rede de teste Görli. Os metadados de cada token são armazenados como um URI de descritor de arquivo (por exemplo, ar://HxXKCIE0skR4siRNYeLKI61Vwg_TJ5PJTbxQmtO0EPo) que deve ser resolvido no lado do cliente, por exemplo, usando gateways de rede de armazenamento descentralizado (Arweave ou IPFS). O contrato não é enumerável, ou seja, os usuários não podem simplesmente consultar seus ativos de propriedade na cadeia, mas devem confiar na leitura dos respectivos registros de eventos para criar seu próprio estado fora da cadeia. Implantamos subgráficos na rede principal e na Görli que podem ser consultados para propriedade de ativos e outras informações relacionadas ao IP-NFT. Aqui está um exemplo do GraphQL sobre como fazer isso:
query IPNFTsOf($owner: ID!)
{
ipnfts(where: {owner: $owner}) {
id
owner
createdAt
tokenURI
}
}
Variáveis:
{
"owner": "0xd1f5B9Dc9F5d55523aB25839f8785aaC74EDE98F"
}
Resultado:
{
"data": {
"ipnfts": [
...
{
"id": "21",
"owner": "0xd1f5b9dc9f5d55523ab25839f8785aac74ede98f",
"createdAt": "1671818892",
"tokenURI": "ar://HxXKCIE0skR4siRNYeLKI61Vwg_TJ5PJTbxQmtO0EPo"
}
]
}
}
Interagindo com contratos inteligentes
Uma instrução detalhada sobre como as contas podem interagir com contratos inteligentes baseados em blockchain está muito fora do escopo deste artigo. Se você é novo nesse espaço, é altamente recomendável se familiarizar com os fundamentos do desenvolvimento da Ethereum e entender como os clientes interagem com contratos implantados usando provedores, signatários, transações e ABIs de contrato.
Implantamos os contratos como proxies UUPS, que pertencem e podem ser atualizados pela equipe de desenvolvedores do Molecule, portanto, o contrato com o qual você está interagindo e o contrato que contém a lógica atual são diferentes. Certifique-se de sempre invocar funções no proxy UUPS — seus endereços oficiais podem ser encontrados no arquivo README do repositório público. Os contratos de implementação foram verificados no Etherscan, para que você possa recuperar facilmente suas ABIs.
Reservando IDs de Tokens
Os IP-NFTs geralmente podem ser cunhados por contas arbitrárias. No entanto, para manter os itens da coleção tão limpos e válidos quanto possível, adicionamos um vigia na frente do método mintReservation que exige que um cunhador mantenha um mintpass válido. Para recuperar um mintpass para uso da rede principal, os usuários podem enviar este formulário de autoatendimento, que notifica a equipe do Molecule para liberar um novo mintpass para o solicitante. Em redes de teste, os usuários podem simplesmente emitir mintpasses para si mesmos, seguindo o fluxo interativo na Interface do Usuário oficial de cunhagem de IP-NFT ou chamando um de nossos métodos dedicados de dispensador de mintpass dispense na cadeia.
Depois de manter um mintpass, a próxima etapa na jornada de cunhagem é reservar um id de token IP-NFT chamando o método reserve()do contrato IP-NFT. Essa etapa de captura é necessária porque os documentos legais anexados ao IP-NFT final são referentes a id do token do NFT, que só fica disponível após a ocorrência da cunhagem. Os cunhadores usarão a ID do token para elaborar os documentos legais que descrevem os direitos e obrigações de possuir esse NFT no mundo real. Uma seleção de modelos de contrato pré-fabricados para IP-NFTs pode ser encontrada no Github.
Reúna e faça upload de metadados
Os documentos de metadados JSON por trás dos IP-NFTs são necessários para validar estritamente em um esquema JSON bem definido que seja flexível o suficiente para cobrir muitos casos de uso relevantes. Aqui está uma ferramenta visual para investigar os metadados de um IP-NFT válido interativamente. Observe que os campos genéricos name, image e descriptionestão localizados no nível raiz do documento, conforme exigido pelo ERC-1155, enquanto as estruturas agreements e project_details são modeladas como definições de propriedades avançadas.
{
"schema_version": "0.0.1",
"name": "Nosso incrível teste IP-NFT",
"description": "Lorem ipsum dolor sit amet, ...",
"image": "ar://7De6dRLDaMhMeC6Utm9bB9PRbcvKdi-rw_sDM8pJSMU",
"external_url": "https://ip-nft.com/1",
"properties": {
"type": "IP-NFT",
"agreements": [
{
"type": "Contrato de licença",
"url": "ar://4FG3GR8qCdLo923tVBC85NTYHaaAc3TvCsF3aZwum_o",
"mime_type": "application/pdf",
"content_hash": "bagaaiera7ftqs3jmnoph3zgq67bgjrszlqtxkk5ygadgjvnihukrqioipndq",
}
],
"project_details": {
"industry": "Pharmaceutical R&D",
"organization": "Newcastle University, UK",
"topic": "Aging",
"research_lead": {
"name": "Chuck Norris",
"email": "[email protected]"
}
}
}
}
Validar a exatidão dos metadados
Para validar documentos de metadados IP-NFT em relação a esse esquema, você pode usar ferramentas arbitrárias de esquema JSON. Ajv é uma das mais poderosas em Javascript. Estamos omitindo o código para recuperar o esquema ou os documentos por uma questão de brevidade, mas, em poucas palavras, a validação se resume a:
import Ajv from "ajv";
import addFormats from "ajv-formats";
(async () => {
const ipnftSchema = JSON.parse(ipnftSchemaJson);
const document = JSON.parse(ipnftMetadataJson);
const ajv = new Ajv();
addFormats(ajv);
const validateIpnft = ajv.compile(ipnftSchema);
const validationResult = validateIpnft(document);
})();
Link para recursos externos
Os documentos de metadados IP-NFT exigem que você consulte recursos externos, por exemplo, os campos imageou agreements[].url Embora você possa optar pelo conhecido protocolo https://, é aconselhável usar ponteiros de armazenamento descentralizado nativo da web3 como ar://ou ipfs://em vez disso. Os clientes devem resolvê-los para suas respectivas contrapartes de gateway http e a maioria dos serviços e front-ends relacionados ao NFT podem lidar com eles. Você não precisa executar um nó Arweave ou IPFS sozinho - Ardrive ou web3.storage são excelentes serviços auxiliares que realizam o trabalho e nossa Interface de Usuário oficial de criação de IP-NFT usa Bundlr para carregar arquivos com eficiência para a rede Arweave com finalização quase instantânea.
Aqui está um exemplo de nodejs sobre como carregar um documento JSON usando web3.storage (é mais simples fazer isso dentro de um contexto de navegador):
import dotenv from "dotenv";
import { Blob } from "node:buffer";
import { Web3Storage } from "web3.storage";
dotenv.config();
const w3sClient = new Web3Storage({ token: process.env.W3S_TOKEN });
(async () => {
const content = {
uploaded_at: new Date().toISOString(),
};
const binaryContent = new Blob([JSON.stringify(content)], {
type: "application/json",
});
const file = {
name: "filename.json",
stream: () => binaryContent.stream(),
};
//@ts-ignorar
const cid = await w3sClient.put([file], {
name: "some.json",
wrapWithDirectory: false,
});
console.log(cid);
})();
Resulta em um IPFS CIDv1:
bafkreicrhuxfzrydht6tmd4kyy6pkbhspqthswg6xbiqlaztmf774ojxhq
Para resolver o conteúdo publicado, você pode solicitá-lo de qualquer gateway IPFS http público. Você experimentará a latência mais baixa ao consultar um gateway próximo ao nó que você usou para carregar; web3.storage oferece https://w3s.link para esse fim. Solicitando rendimentos https://w3s.link/ipfs/bafkreicrhuxfzrydht6tmd4kyy6pkbhspqthswg6xbiqlaztmf774ojxhq
{ "uploaded_at" : "2023-01-02T22:45:17.788Z" }
Criptografia descentralizada e bloqueio de token IP-NFT
A propriedade de metadados mais importante de um IP-NFT é seu agreements, outro termo para documentos legais anexados a ele. Esses documentos referem-se ao endereço do contrato inteligente IP-NFT (“coleção”) e a ID do token do IP-NFT. O conteúdo dos acordos pode conter informações confidenciais sobre as partes envolvidas e, portanto, deve ser criptografado antes de ser carregado. A criptografia descentralizada e sem necessidade de permissão de terceiros é um requisito não trivial que resolvemos contando com o Protocolo Lit.
O Lit executa uma rede de nós que derivam chaves de assinatura e criptografia por computação multipartidária/criptografia de limiar em enclaves de computação confiáveis. Os próprios nós conhecem apenas partes da chave privada que efetivamente são totalmente montadas no lado do cliente depois que todas as condições para recuperação da chave foram atendidas. O protocolo Lit permite bloquear qualquer conteúdo por trás das condições de controle de acesso apoiadas pelo estado da blockchain. Portanto, está divulgando chaves de descriptografia apenas para detentores de um NFT ou usuários que atendem a uma determinada condição na cadeia.
A documentação do Lit apresenta o processo de criptografia em detalhes. Para instanciar uma instância Lit SDK capaz de criptografar ou descriptografar conteúdo, ela precisa de uma assinatura compatível com EIP-4361 que comprove o controle sobre a conta do usuário atual. Depois de autenticados, podemos solicitar uma nova chave simétrica para criptografar nosso conteúdo e, por fim, solicitar aos nós da rede Lit que armazenem seus compartilhamentos de chave junto com uma condição de controle de acesso. Essa solicitação gera uma chave de descriptografia criptografada (😵💫) que foi criada pelos nós da rede.
import LitJsSdk from '@lit-protocol/sdk-browser'
const litClient = new LitJsSdk.LitNodeClient()
await client.connect() //conecta-se aos nós de rede Lit
const file: Blob | File = //algum arquivo
const { encryptedFile, symmetricKey } = await LitJsSdk.encryptFile({ file })
//você pode reutilizar uma mensagem assinada Siwe / EIP-4361 compatível aqui, veja em https://login.xyz/
const authSig = await LitJsSdk.checkAndSignAuthMessage({ chain: "ethereum" });
accessControlConditions = {
conditionType: 'evmBasic',
contractAddress: tokenContractAddress,
standardContractType: 'ERC1155',
chain: "ethereum",
method: 'balanceOf',
parameters: [':userAddress', tokenId],
returnValueTest: {
comparator: '>',
value: '0' // o usuário possui mais de 0 deste ID de token
}
}
const u8encryptedSymmetricKey = await litClient.saveEncryptionKey({
unifiedAccessControlConditions: accessControlConditions,
symmetricKey,
authSig,
chain,
permanent: false
})
Um usuário que deseja descriptografar o conteúdo deve inicializar novamente o SDK usando uma mensagem assinada que comprove o controle sobre seu endereço. Em seguida, eles pedem a vários nós da rede que apresentem seus compartilhamentos da chave criptografada, apresentando as condições de controle de acesso e a chave simétrica criptografada para a rede. Se os nós da rede descobrirem que a conta corresponde às condições fornecidas, cada um cederá seu compartilhamento de chave para a chave de descriptografia criptografada. Com isso, o SDK descriptografa a chave com a qual o conteúdo foi inicialmente criptografado.
const authSig = await LitJsSdk.checkAndSignAuthMessage({ chain: "ethereum" });
const symmetricKey = await litClient.getEncryptionKey({
unifiedAccessControlConditions: accessControlConditions,
toDecrypt: encryptedSymmetricKey,
chain: "ethereum",
authSig
})
Um item de metadados IP-NFT agreementspode armazenar a chave simétrica criptografada e suas condições de controle de acesso dentro de seu campo encryption. Observe que o esquema IP-NFT JSON access_control_conditionsé definido externamente pelo protocolo Lit.
"agreements": [
{
"type": "License Agreement",
"url": "ar://4FG3GR8qCdLo923tVBC85NTYHaaAc3TvCsF3aZwum_o",
"mime_type": "application/pdf",
"content_hash": "bagaaiera7ftqs3jmnoph3zgq67bgjrszlqtxkk5ygadgjvnihukrqioipndq",
"encryption": {
"protocol": "lit",
"encrypted_sym_key": "fcbeaf3af31c7104d1d1f7099a6c6f6fda5803a4f7a0bef93256f3377450291872ad07bed3e9402cb47cc932c8f48219e56b84c06becd5ec0ee83ef2c0c93b932fb675c7932fa8df0ad164f17642b32415e382081577a403c19da2eff22c9083fa134ad1f370c2bec449adcdea790498637c7238b7d67cf2d69507a962656d3200000000000000205e4ad4e6323e06862babc934f740bc2e566d175a5da23bb4f1b35635e5cc3768cd040e8776307ea038484ff42033c18f",
"access_control_conditions": [
{
"conditionType": "evmBasic",
"contractAddress": "0xa1c301d77f701037f491c074e1bd9d4ac24cf5e5",
"standardContractType": "ERC1155",
"chain": "goerli",
"method": "balanceOf",
"parameters": [
":userAddress",
"6"
],
"returnValueTest": {
"comparator": ">",
"value": "0"
}
}
]
}
}
]
Usando assinantes de carteira Multisig
Devido à natureza de alto valor dos IP-NFTs, você pode se sentir tentado a usar uma carteira multisig para o processo de cunhagem, talvez porque queira provar que o IP-NFT foi criado por um grupo dedicado de indivíduos. Isso funciona bem para todas as invocações de função de contrato, mas não é compatível com o protocolo Lit. As carteiras multisig (ou carteiras de contrato, para ser mais preciso) não podem assinar mensagens da maneira necessária para autenticar nos nós do Lit porque não são baseadas em uma chave privada. Isso pode ser possível utilizando assinaturas de carteira compatíveis com EIP-1271, mas não é suportado no momento da escrita.
A solução alternativa recomendada é denotar um membro confiável dedicado da multisig, que supostamente possui inicialmente o IP-NFT cunhado. Pode ser o pesquisador, um colaborador principal ou mantenedor do projeto. A função mintReservationdo contrato IP-NFT recebe um parâmetro de destinatário (to) que define o proprietário inicial do NFT. Observe que a conta que invoca a função mint é necessária para manter um passe mint, não o destinatário.
Concedendo acesso de leitura a terceiros
Outra deficiência relacionada ao requisito de assinaturas de autenticação baseadas em chave privada do Lit é que os detentores de token multisig não podem provar seu endereço para o protocolo. Para permitir que os membros multisig descriptografem os documentos do contrato que os acompanham, o contrato IP-NFT contém um arquivo grantReadAccess. Ele pode ser invocado pelo detentor do token atual (por exemplo, uma multisig) para conceder a certas contas (por exemplo, alguns de seus membros ou compradores em potencial) acesso de leitura ao conteúdo subjacente por um período de tempo limitado. Sua contraparte canRead gera um booleano se o acesso reader é permitido no momento. Para o proprietário atual de um IP-NFT, esse método sempre retorna true.
Para fazer as concessões de leitura funcionarem dentro do protocolo Lit, pode-se criar uma condição de controle de acesso de contrato personalizado que não apenas leva em consideração a propriedade IP-NFT atual, mas também permite que os usuários passem que atualmente recebem acesso de leitura:
"encryption": {
"protocol": "lit",
"encrypted_sym_key": "...",
"access_control_conditions": [
{
"conditionType": "evmContract",
//o endereço do contrato proxy IP-NFT UUPS
"contractAddress": "0x36444254795ce6E748cf0317EEE4c4271325D92A",
"chain": "goerli",
"functionName": "canRead",
"functionParams": [
":userAddress",
"10"
],
"functionAbi": {
"name": "canRead",
"inputs": [
{
"internalType": "address",
"name": "reader",
"type": "address"
},
{
"internalType": "uint256",
"name": "tokenId",
"type": "uint256"
}
],
"outputs": [
{
"internalType": "bool",
"name": "",
"type": "bool"
}
],
"stateMutability": "view",
"type": "function"
},
"returnValueTest": {
"key": "",
"comparator": "=",
"value": "true"
}
}
]
}
Comprovando a integridade do conteúdo
Como os documentos do contrato são criptografados antes de serem armazenados, cada item do contrato pode conter um content_hash que os as pessoas que fazem download podem usar para provar a integridade do conteúdo dos documentos legais depois de descriptografá-los. Ao usar o IPFS como camada de armazenamento, esse hash não agrega muito valor, pois as IDs de conteúdo da rede já fornecem uma maneira inviolável de garantir a integridade do conteúdo; no entanto, eles não são derivados do conteúdo original e são difíceis de provar sem um nó IPFS disponível.
O campo content_hashdeve conter o resumo sha-256 do conteúdo binário do anexo, codificado como um multihash compatível com CIDv1. Isso permite que os clientes decodifiquem o hash do conteúdo e verifiquem o conteúdo de um documento sem estarem cientes do algoritmo de hash usado. É assim que fica no Typescript usando o pacote multiformats NPM:
import { CID } from "multiformats/cid";
import * as json from "multiformats/codecs/json";
import { sha256 } from "multiformats/hashes/sha2";
const checksum = async (u8: Uint8Array) => {
//https://multiformats.io/multihash/
const digest = await sha256.digest(u8);
return CID.create(1, json.code, digest);
};
const verifyChecksum = async (
u8: Uint8Array,
_cid: string
): Promise<boolean> => {
const cid = CID.parse(_cid);
//https://github.com/multiformats/multicodec/blob/master/table.csv#L9
console.log("hash algo used: 0x%s", cid.multihash.code.toString(16));
const digest = await sha256.digest(u8);
return cid.multihash.bytes.every((el, i) => el === digest.bytes[i]);
};
(async () => {
const binaryContent = new TextEncoder().encode("This is the content");
const cid = await checksum(binaryContent);
const valid = await verifyChecksum(binaryContent, cid.toString());
console.log(cid, valid);
})();
Juntando tudo: o fluxo de criação de IP-NFT para desenvolvedores
Resumindo, cunhar um IP-NFT requer tecnicamente as seguintes etapas:
- Obtenha um Mintpass para a conta que deve finalmente invocar a função
mintReservation. - Invoque a função
reserve()do contrato IPNFT para reservar uma ID de token. Isso será revertido se o chamador não estiver segurando um Mintpass válido. Obtenha a ID do token reservado analisando os registros de eventos do método. - Faça upload de uma imagem para uma rede (des)centralizada de sua escolha.
- Use a id do token e o endereço do contrato IPNFT para criar documentos legais.
- Calcule uma soma de verificação sobre os documentos originais.
- Opcionalmente, criptografe os documentos com uma condição de controle de acesso Lit.
- Monte uma estrutura de metadados contendo os ponteiros de arquivo, condições de controle de acesso, chave simétrica criptografada e soma de verificação.
- Verifique se esta estrutura de metadados é válida.
- Faça o upload dos metadados para uma rede (des)centralizada de sua escolha.
-
Invoque
mintReservationno contrato IPNFT comaddress to: o destinatário do NFT cunhado (por exemplo, uma carteira Multisig);uint256 reservationId: a ID do token que você reservou;uint256 mintPassId: a ID do Mintpass que será resgatado durante a cunhagem;string memory tokenURI: o URI que resolve os metadados.
Conclusão
Os IP-NFTs são primitivos DeSci que permitem que pesquisadores, instituições e laboratórios criem prematuramente as implicações legais de seu trabalho como um ativo negociável e verificável. Eles funcionam como âncoras de propriedade fundamentais que podem ser usadas para referenciar e bloquear o acesso a outros tipos de conteúdo protegido, por exemplo, modelos de aprendizado de máquina, fluxos de dados ou documentos não públicos. Sendo construídos em interfaces padrão bem conhecidas, eles podem ser negociados ou fracionados usando uma vasta gama de protocolos que já existem hoje.
Como você aprendeu aqui, o processo de cunhagem de IP-NFTs não é uma tarefa trivial, principalmente se eles contêm referências a conteúdo criptografado. No entanto, seu esquema de metadados é projetado para ser flexível o suficiente para cobrir muitos casos de uso relacionados à Propriedade Intelectual e a interface de contrato do IP-NFT deve ser simples de interagir.
O contrato IP-NFT é implantado como um contrato atualizável mantido pela equipe principal do Molecule e planejamos adicionar recursos mais interessantes a ele em um futuro próximo. Você pode encontrar todas as fontes relevantes em nosso repositório do Github oficial e versões executáveis dos exemplos de código descritos neste artigo no repositório de exemplos que o acompanha.
Artigo escrito por Stefan Adolf e traduzido por Marcelo Panegali.
Oldest comments (0)