数字藏品

Author: Sheldor3

generate_metadata.js

@@ -0,0 +1,104 @@
+const fs = require("fs");
+const path = require("path");
+const { loadImage } = require("canvas");
+
+const basePath = process.cwd();
+const buildDir = `${basePath}/build/json`;
+const inputDir = `${basePath}/build/images`;
+const namePrefix = "sneaker";
+const description = "sneakernft world";
+const baseUri = "ipfs://NewUriToReplace";
+const console = require("console");
+
+const metadataList = [];
+
+const buildSetup = () => {
+  if (fs.existsSync(buildDir)) {
+    fs.rmdirSync(buildDir, { recursive: true });
+  }
+  fs.mkdirSync(buildDir);
+};
+
+const getImages = (_dir) => {
+  try {
+    return fs
+      .readdirSync(_dir)
+      .filter((item) => {
+        let extension = path.extname(`${_dir}${item}`);
+        if (extension == ".png" || extension == ".jpg") {
+          return item;
+        }
+      })
+      .map((i) => {
+        return {
+          filename: i,
+          path: `${_dir}/${i}`,
+        };
+      });
+  } catch {
+    return null;
+  }
+};
+
+const loadImgData = async (_imgObject) => {
+  try {
+    const image = await loadImage(`${_imgObject.path}`);
+    return {
+      imgObject: _imgObject,
+      loadedImage: image,
+    };
+  } catch (error) {
+    console.error("Error loading image:", error);
+  }
+};
+
+
+
+const saveMetadata = (_loadedImageObject) => {
+  let shortName = _loadedImageObject.imgObject.filename.replace(
+    /\.[^/.]+$/,
+    ""
+  );
+
+  
+
+  let tempMetadata = {
+    name: `${namePrefix} #${shortName}`,
+    description: description,
+    image: `${baseUri}/${shortName}.png`,
+};
+  fs.writeFileSync(
+    `${buildDir}/${shortName}.json`,
+    JSON.stringify(tempMetadata, null, 2)
+  );
+  metadataList.push(tempMetadata);
+};
+
+const writeMetaData = (_data) => {
+  fs.writeFileSync(`${buildDir}/_metadata.json`, _data);
+};
+
+const startCreating = async () => {
+  const images = getImages(inputDir);
+  if (images == null) {
+    console.log("Please generate collection first.");
+    return;
+  }
+  let loadedImageObjects = [];
+  images.forEach((imgObject) => {
+    loadedImageObjects.push(loadImgData(imgObject));
+  });
+  await Promise.all(loadedImageObjects).then((loadedImageObjectArray) => {
+    loadedImageObjectArray.forEach((loadedImageObject) => {
+      
+      saveMetadata(loadedImageObject);
+      console.log(
+        `Created metadata for image: ${loadedImageObject.imgObject.filename}`
+      );
+    });
+  });
+  writeMetaData(JSON.stringify(metadataList, null, 2));
+};
+
+buildSetup();
+startCreating();

sneaker.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT;
+
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
+import "@openzeppelin/contracts/utils/Counters.sol";
+
+
+contract Sneaker is ERC1155 {
+
+    using Counters for Counters.Counter;
+    Counters.Counter private _tokenId;
+
+    mapping(uint => string) private _tokenURIs;
+
+    constructor() ERC1155("ipfs://bafybeiglsd5it3st6h3znasju72rz7lndyz7325x2nez6g6jcvetsuvrom/") {}
+
+    function mint(address _recipient,uint _amount, string memory _tokenUrl) public returns(uint _mintTokenId){
+        require(bytes(_tokenUrl).length > 0,"The _tokenUrl must be have");
+        require(_amount > 0,"The _amount must be have");
+        _tokenId.increment();
+        uint newTokenId = _tokenId.current();
+        _mint(_recipient, newTokenId,_amount,"");
+        _tokenURIs[newTokenId] = _tokenUrl;
+        return newTokenId;
+    }                
+
+    function mintBatch(address _recipient,uint[] memory _amounts,string[] memory _tokenUrls) public returns(uint[] memory _mintTokenIds){
+        require(_amounts.length > 0,"The _amounts must be have");
+        require(_tokenUrls.length > 0,"The _tokenUrls must be have");
+        require(_amounts.length == _tokenUrls.length,"The _tokenUrl length must be Equal _amounts length");
+
+        uint newTokenId;
+        uint[] memory returnTokenUrls = new uint[](_amounts.length);
+
+        for(uint256 i = 0; i < _amounts.length; i++){
+            _tokenId.increment();
+            newTokenId = _tokenId.current();
+            _tokenURIs[newTokenId] = _tokenUrls[i];
+            returnTokenUrls[i] = newTokenId;
+        }
+
+        _mintBatch(_recipient, returnTokenUrls,_amounts,"");
+
+        return returnTokenUrls;
+    }
+
+    function uri(uint256 _id) public view override returns(string memory _tokenUrl){
+        return _tokenURIs[_id];
+        
+    }
+
+    function uriBatch(uint[] memory _tokenIds) public view returns(string[] memory _tokenUrls){
+        require(_tokenIds.length > 0,"The _tokenId must be have");
+
+        string[] memory returnTokenUrl = new string[](_tokenIds.length);
+
+        for(uint256 i=0;i<_tokenIds.length;i++){
+            returnTokenUrl[i] = _tokenURIs[_tokenIds[i]];
+        }
+
+        return returnTokenUrl;
+    }
+
+}

storeDirectory.mjs

@@ -0,0 +1,27 @@
+import { NFTStorage } from 'nft.storage'
+import { filesFromPath } from 'files-from-path'
+import path from 'path'
+
+const token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJkaWQ6ZXRocjoweDQwNmZBM0VGMDI3N0M3ODBFMUE4RUIyODlDN2QxYjI4OGUxQ0ExOEQiLCJpc3MiOiJuZnQtc3RvcmFnZSIsImlhdCI6MTY2MTQwNzEzMzgwNywibmFtZSI6ImNyc2UifQ.-G1OkaAjDt0yQgW243oGWqE9TX-iVVYfFUgVVW6t39I'
+
+async function main() {
+  // you'll probably want more sophisticated argument parsing in a real app
+  if (process.argv.length !== 3) {
+    console.error(`usage: ${process.argv[0]} ${process.argv[1]} <directory-path>`)
+  }
+  const directoryPath = process.argv[2]
+  const files = filesFromPath(directoryPath, {
+    pathPrefix: path.resolve(directoryPath), // see the note about pathPrefix below
+    hidden: true, // use the default of false if you want to ignore files that start with '.'
+  })
+
+  const storage = new NFTStorage({ token })
+
+  console.log(`storing file(s) from ${path}`)
+  const cid = await storage.storeDirectory(files)
+  console.log({ cid })
+
+  const status = await storage.status(cid)
+  console.log(status)
+}
+main()