I know it is possible to set the smaller collection image using the contract metadata, but is there a way to set the larger banner image?
https://docs.opensea.io/docs/contract-level-metadata
I also know you can set it through the UI if you are the contract owner but the contract is being owned by a system account with no access to the private keys to add in MetaMask.
No...
You need to contract OpenSea directly to have them set the ownership of the collection to another wallet you control.
Related
I'm working on an NFT project, Once I created an item on Rarible, and after that login on to Opensea with the same wallet address. Then the item I was created on Rarible is automatically synced to Opensea including title, history, etc.
So, As a programmer. I want to know the reason behind this process and how they are getting this data from one to another using the same wallet.
When any contract writes an ERC721 compliant transaction to Ethereum, marketplaces like OpenSea and Rarible are able to monitor new blocks (e.g. via event streaming) for new token creation. Since this information is public, information such as the issuing contract id, owner address and token id are immediately available and can be retrieved. Additional information about the contract can also be obtained from the contract constructor.
Additionally, one of the methods on an ERC721 contract is tokenURI. By navigating to this URI (often stored on immutable storage like IPFS), anyone observing the blockchain can retrieve additional metadata information about the token. This metadata usually includes an image, description and other custom attributes which describe the NFT. This allows marketplaces to render the NFT on their exchanges.
I understand what NFT is – it is an entry in the Blockchain, I understand what a digital product is - for example, it is a physical file with an image.
I want to create an NFT for this image. This is what I don't understand so far - where will the information between the NFT and the image be stored to prove that this particular NFT is made specifically for that particular image?
As per the ERC721 and ERC1155 standards, there is just a one-way link from the token to the image. Which theoretically allows multiple NFTs representing the same image.
Each collection contract implements a function to retrieve a metadata JSON file. In case of ERC721 that's tokenURI(uint256 tokenId), and in case of ERC1155 that's uri(uint256 tokenId), both returning a string with the metadata file location. This file can be stored on a private server, a decentralized storage (e.g. IPFS), an FTP, ... simply behind any valid URI.
And according to both standards, the metadata file should contain a JSON field named image containing URI of the actual image file.
TLDR: A one-way link from the NFT to the image is in the metadata file of each NFT. There is no standardized way to link from the image back to the NFT.
I've posted 1000 NFT images on Rarible via 'lazy minting'. All images go to a public folder (collection) by default on Rarible, if you don't pay. Now I would like to show (copy) this set of images also on OpenSea. How can I do that?
What if I would like to move my NFT images from the Rarible public repository to a custom collection on Rarible? How to do that?
Only Rarible allows the lazy-minting option you can't directly import from Rarible to Opensea unless you have deployed on-chain.
Lazy-minting on Rarible works off-chain when a user buys your NFT he pays the gas fees then it mints on-chain. Also you can't create a custom collection without Smart Contract.
You can import Rarible-Opensea using ERC-721 or ERC-1155 contract - https://opensea.io/get-listed
Also, how did you post 1000 images to Rarible? Using Macro recorder?
I am not sure what I don't know and if this is possible. I think this would be a similar issue for Ethereum, so that is the reason why I marked Ethereum on tags.
I am going to describe on example what I want to achieve:
There is a token called "Elonomics".
https://bscscan.com/address/0xd3ecc6a4ce1a9faec1aa5e30b55f8a1a4b84f938
there is owner with address "0x3a78ea5c462f0afa76fa091a70a7bcd020b274d6"
there are all txs from owner address: https://bscscan.com/txs?a=0x3a78ea5c462f0afa76fa091a70a7bcd020b274d6
when I take one of the transaction from the owner e.g. 0x6f81f2dbd285d772c6b34151b676f6749ef75ac9a6c76b5e4dfa844a0c6932d2"
I can read the logs from this transaction in:
https://bscscan.com/tx/0x6f81f2dbd285d772c6b34151b676f6749ef75ac9a6c76b5e4dfa844a0c6932d2#eventlog
so I can read that somebody set "totalSupply :1500000800000"
and now are my questions:
Is it possible to fetch all txs related to this specific owner address with these logs in json data (or any other data that can be updated dynamically on dAPPs)?
Are data from txs logs are encrypted? (if yes what is the format of this and how to decrypt this how bscscan do)
Is it possible to fetch these data directly from blockchain instead of using 3rd part application like bscscan?
Is it possible to fetch all txs related to this specific owner address with these logs in json data (or any other data that can be updated dynamically on dAPPs)?
Yes, because all this data is stored on a blockchain.
Are data from txs logs are encrypted? (if yes what is the format of this and how to decrypt this how bscscan do)
All data on a public blockchain is public.
Is it possible to fetch these data directly from blockchain instead of using 3rd part application like bscscan?
Run your own BSC node. Please see web3.py library how to interact with an Ethereum based blockchain, like one that is BSC node.
The following use case would it be possible ?
At a nation level, the government wants its regional educational direction to build a system to certify diplomas. Those diplomas should be stored on a blockchain in such a way that no region could, alone, temper them after they were issued.
The students should be able to give access temporally to his or her diplomas, to anyone (eg. employer wanting to recruit).
Please correct me:
I think this should be possible if the data stored on the blockchain was encrypted and if the DAPP was able to generate temporary key to decrypt that data.
Obviously any employer gaining access to the record could make a copy of it, but the point here is that after the expiration of the key's validity, no employer should be able to prove that he owned the real record.
Does that sound like a valid use case for dapps in general. Does it sound even feasible to you ?
The following scenario can be suggested as the simplest option:
We create a smart contract with 3 methods:
RegistryRequest(bytes32 info_id, bytes32 user_id, string memory public_cert) payeble
SendInfo(bytes32 info_id, bytes32 user_id, string file_addr)
GetInfo(bytes32 info_id, bytes32 user_id) view return(string memory retVal)
The consumer calls the method RegistryRequest transfers:
info_id - the identifier of the required data
user_id - his unique identifier (e-mail, mobile phone, and so on) ()
public_cert- his public key OpenSSL
and attaches a certain amount in Eth to the transaction as payment for the service.
Having received the details and payment from the consumer, you:
create a file with the data he needs
encrypt this file with the consumer's public key OpenSSL,
upload it to some web resource or transfer it via IPFS or Ethereum Swarm (or in any other way)
using the method SendInfo lay out the "address" of the data file (file_addr) in relation to the data and consumer identifiers (info_id, user_id).
To pay for the transaction, you use a portion of the amount received from the consumer along with the RegistryRequest.
The consumer through the method GetInfo using the data identifier (info_id) and his personal identifier (user_id) receives the "address" of the data file, extracts and decrypts it
If the data changes, then their changed state is laid out similarly to point 3
After the expiration of the data provision period, you stop releasing their update
More complex solutions can, for example, be discussed with experts for free and simulated on a kekker.com