Dynamic NFTを作る（決定版）

const http = require("http");
const { exFunction } = require("./service");

const server = http.createServer((req, res) => {
    if (req.method == "POST") {
        let job;
        req.on("data", async (json) => {
            job = await JSON.parse(json);
        }).on("end", async () => {
            const ret = await exFunction(job.data.image, job.data.address, job.data.name)
                                        
            const json = {
                "data": ret
            }
            res.end(JSON.stringify(json));
        });
    } else {
        res.end(JSON.stringify({}));
    }
});

server.listen(5000);

const canvasInit = async (x, y) => {
    canvas = createCanvas(x, y);
    ctx = canvas.getContext("2d");
}

// ./input/usrIcon.png -> ./output/icon.png
const iconCreating = async (url) => {
    const icon = await loadImage(url);
    const iw = icon.width;
    const ih = icon.height;
    await canvasInit(iw, ih);

    if (iw >= ih) {
        canvas.height = 160;
        canvas.width = 160 * iw / ih;
        ctx.arc( 80 * iw /ih, 80, 75, 0 * Math.PI / 180, 360 * Math.PI / 180 );
        ctx.clip();
        ctx.drawImage(icon, 0, 0, canvas.width, canvas.height);
    } else {
        canvas.height = 160 * ih / iw;
        canvas.width = 160;
        ctx.arc( 80, 80 * iw /ih, 75, 0 * Math.PI / 180, 360 * Math.PI / 180 );
        ctx.clip();
        ctx.drawImage(icon, 0, 0, canvas.width, canvas.height);
    }
    fs.writeFileSync("./output/icon.png", canvas.toBuffer("image/png"));
}

const CardCreating = async (text) => {
    let filepath = "./input/roundrobin.png";
    let iconpath = "./output/icon.png";
    await canvasInit(1000, 1000);
    const background = await loadImage(filepath);
    const icon = await loadImage(iconpath);
    canvas.height = background.height;
    canvas.width = background.width;
    ctx.drawImage(background, 0, 0);
    ctx.font = '32px fantasy';
    ctx.fillStyle = '#FFFFFF';
    ctx.textBaseline = 'center';
    ctx.textAlign = 'center';
    var x = (canvas.width / 2);
    var y = (canvas.height / 2);
    var y = (canvas.height / 2);
    var ix = (icon.width / 2);
    var iy = (icon.height / 2);
    ctx.translate(x, y);
    ctx.rotate(-22 * Math.PI / 180);
    ctx.translate(-x, -y);
    ctx.drawImage(icon, x - ix, y - iy - 40);
    ctx.fillText(text, x, y + 85);
    fs.writeFileSync("./output/magicplank.png", canvas.toBuffer("image/png"));
}

const uploadImage = async(data) => {
    // data from ./output/icon.png
    const base64 = await btoa(fs.readFileSync("./output/magicplank.png"));
    const file = new Moralis.File("magicplank.png", { base64: `data:image/png;base64,${base64}` });
    await file.saveIPFS({ useMasterKey: true });
    console.log("IPFS address of Image: ", file.ipfs());
    return file.ipfs();
}

const getURIonIPFS = async() => {
    const imageURL = await uploadImage();

    const metadata = {
        "name": "DynamicNFT",
        "description": "This is DynamicNFT.",
        "image": imageURL
    }
    
    const file = new Moralis.File("file.json", { base64: btoa(JSON.stringify(metadata)) });
    await file.saveIPFS({ useMasterKey: true });
    console.log("IPFS address of metadata", file.ipfs());
    return file.ipfs();
}

// upload the image and metadata on IPFS and encoding the URL, then return it
    const ipfs = await getURIonIPFS();
    const ipfsVar = ipfs.slice(34); // cut off "https://ipfs.moralis.io:2053/ipfs/"
    const len = ipfsVar.length / 2;
    const byte0 = ethers.utils.formatBytes32String(ipfsVar.slice(0, len));
    const byte1 = ethers.utils.formatBytes32String(ipfsVar.slice(len));
    return { "furi": byte0, "luri": byte1, "name": ethers.utils.formatBytes32String(name) }

$ git clone https://github.com/BlueGamma/ExternalAdapter.git
$ npm install

#画像データを出力するための空ファイルを作成します
$ mkdir ./ExternalAdapter/output

$ npm run start

.
├── chainlink-node ── run-node ── docker-compose.yml
└── external-adapter 

version: '3'
services:
  pg_chainlink:
    image: "postgres"
    ports:
      - "5434:5434"
    env_file:
      - database.env
    volumes:
      - [PATH_TO_POSTGRES_DATA]:/var/lib/postgressql/data/
  
  chainlink:
    image: "smartcontract/chainlink:1.2.0"
    env_file: .env
    depends_on:
      - pg_chainlink
    ports:
      - "6688:6688"
    volumes:
      - [PATH_TO_REPO_CHAINLINK_VOLUME]:/chainlink/
    command: node start --password /chainlink/password.txt --api /chainlink/apicredentials.txt 
  
  adapter:
    container_name: adapter
    ports:
      - "5000:5000"
    build:
      context: ../ExternalAdapter
      dockerfile: ./Dockerfile
    restart: on-failure
    command: npm start

YOUR_MAIL_ADDRESS
YOUR_LOGIN_PASSWORD

secret

#ETH_CHAIN_ID=4 Rinkeby Testnet
#ETH_CHAIN_ID=42 Kovan Testnet
#ETH_CHAIN_ID=1 Mainnet
#ETH_CHAIN_ID=3 Ropsten Testnet

#LINK_CONTRACT_ADDRESS=Contract where $LINK is located https://ropsten.etherscan.io/address/0x20fE562d797A42Dcb3399062AE9546cd06f63280
#DATABASE_URL=postgresql://$USERNAME:$PASSWORD@$DOCKER_INSTANCE_NAME:5432/$DATABASE?sslmode=disable

ROOT=/chainlink
LOG_LEVEL=debug
MIN_OUTGOING_CONFIRMATIONS=2
ETH_CHAIN_ID=4
LINK_CONTRACT_ADDRESS=0x01BE23585060835E02B77ef475b0Cc51aA1e0709
CHAINLINK_TLS_PORT=0
SECURE_COOKIES=false
GAS_UPDATER_ENABLED=true
FEATURE_FLUX_MONITOR=true
CHAINLINK_DEV=true
ALLOW_ORIGINS=*
DATABASE_URL=postgresql://postgres:secret@pg_chainlink:5432/chainlink?sslmode=disable
ETH_URL=wss://rinkeby.infura.io/ws/v3/734287574c4b493da95a5788ea9cb70d
DATABASE_TIMEOUT=0

POSTGRES_USER=postgres
POSTGRES_PASSWORD=secret
POSTGRES=_DB=chainlink

# psql -U postgres -h localhost
postgres=# CREATE DATABASE chainlink;

$ docker-compose up

type = "directrequest"
schemaVersion = 1
name = "Get > Byte32"
externalJobID = "1da91556-c78d-4fe8-9184-498f2387f58f"
maxTaskDuration = "0s"
contractAddress = "0x3217a8A47de2EdE4170B6B2045f191386F6Ff4b7"
minIncomingConfirmations = 0
observationSource = """
    decode_log    [type="ethabidecodelog"
                   abi="OracleRequest(bytes32 indexed specId, address requester, bytes32 requestId, uint256 payment, address callbackAddr, bytes4 callbackFunctionId, uint256 cancelExpiration, uint256 dataVersion, bytes data)"
                   data="$(jobRun.logData)"
                   topics="$(jobRun.logTopics)"
                   ]
    decode_cbor   [type="cborparse" data="$(decode_log.data)"]
    fetch_opensea [type="http" method=GET url="$(decode_cbor.get)"]

    decode_log -> decode_cbor -> fetch_opensea

    fetch_opensea -> parse_image
    fetch_opensea -> parse_address
    fetch_opensea -> parse_name

    parse_image   [type="jsonparse" path="$(decode_cbor.path_image)" data="$(fetch_opensea)"]
    parse_address [type="jsonparse" path="$(decode_cbor.path_address)" data="$(fetch_opensea)"]
    parse_name    [type="jsonparse" path="$(decode_cbor.path_name)" data="$(fetch_opensea)"]

    parse_image -> generate
    parse_address -> generate
    parse_name -> generate

    generate [type=bridge name="generate"
              requestData="{\\"data\\":{\\"image\\": $(parse_image),\\"address\\":$(parse_address),\\"name\\": $(parse_name)}}"
             ]

    generate -> parse_furi
    generate -> parse_luri
    generate -> parse_bname

    parse_furi  [type="jsonparse" path="data,furi" data="$(generate)"]
    parse_luri  [type="jsonparse" path="data,luri" data="$(generate)"]
    parse_bname [type="jsonparse" path="data,name" data="$(generate)"]

    parse_furi -> encode_data
    parse_luri -> encode_data
    parse_bname -> encode_data

    encode_data [type="ethabiencode"
                 abi="(bytes32 requestId, bytes32 furi, bytes32 luri, bytes32 name)"
                 data="{ \\"requestId\\": $(decode_log.requestId), \\"furi\\": $(parse_furi), \\"luri\\": $(parse_luri), \\"name\\": $(parse_bname) }"
                ]
    encode_tx   [type="ethabiencode"
                 abi="fulfillOracleRequest2(bytes32 requestId, uint256 payment, address callbackAddress, bytes4 callbackFunctionId, uint256 expiration, bytes calldata data)"
                 data="{\\"requestId\\": $(decode_log.requestId), \\"payment\\": $(decode_log.payment), \\"callbackAddress\\": $(decode_log.callbackAddr), \\"callbackFunctionId\\": $(decode_log.callbackFunctionId), \\"expiration\\": $(decode_log.cancelExpiration), \\"data\\": $(encode_data)}"
                ]
    submit_tx   [type="ethtx" to="0x3217a8A47de2EdE4170B6B2045f191386F6Ff4b7" data="$(encode_tx)"]

    encode_data -> encode_tx -> submit_tx
"""

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
import "@chainlink/contracts/src/v0.7/Operator.sol";

# Hardhatと必要なライブラリのインストール
$ npm init -y
$ npm install --save-dev hardhat
$ npm install --save-dev @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle ethereum-waffle chai @openzeppelin/contracts　@chainlink/contracts

# Hardhatの起動(起動画面でCreate an empty hardhat.config.jsを選択してください)
$ npx hardhat

# ディレクトリの作成
$ mkdir contracts scripts

const { privateKey, alchemyApiKey } = require("./secrets.json");

require("@nomiclabs/hardhat-waffle");
require("@nomiclabs/hardhat-ethers");

module.exports = {
  solidity: {
    version: "0.8.4",
    settings:{
      optimizer:{
        enabled: true,
        runs: 200
      }
    }
  },
  networks: {
    hardhat: {},
    rinkeby: {
      url: "https://eth-rinkeby.alchemyapi.io/v2/" + alchemyApiKey,
      chainId: 4,
      accounts: [ privateKey ]
    }
  }
};

{
  "privateKey": "~",
  "alchemyApiKey": "~"
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@chainlink/contracts/src/v0.8/ChainlinkClient.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

/**
 * @title MagicPlank
 * @author tomoking
 * @notice ERC721
 */
contract MagicPlank is ERC721URIStorage, ChainlinkClient, Ownable {
    using Chainlink for Chainlink.Request;
    using SafeMath for uint256;
    using Counters for Counters.Counter;
    using Strings for uint256;

    Counters.Counter private _robinCounter;

    //@notice 列挙型グレード
    enum Rarity {STANDARD, EPIC, LEGEND}

    //@notice 会員証ごとの継承者数
    mapping(uint256 => uint256) RobinsToSuccessors;
    //@notice 会員証ごとの継承者名マッピング
    mapping(uint256 => string) Successors; 
    //@notice 会員証ごとのグレード
    mapping(uint256 => Rarity) public tokenIdToRarity;
    mapping(uint256 => address) toAddr;
    mapping(uint256 => string) strToAddr;

    //ユーザーデータ
    string public strData;
    string private _transitionUri;
    string private robinUri;
    string private baseUrl = "https://testnets-api.opensea.io/api/v1/assets?format=json&limit=1&offset=0&order_direction=desc&owner=";

    //Chainlinknode情報
    address private oracle;
    bytes32 private jobId;
    uint256 private fee;

    uint256 private currentRobinId;

    //@title コンストラクタ
    constructor(string memory initialUri_)ERC721("MagicPlank","MP"){
      _transitionUri = initialUri_;
      setPublicChainlinkToken();
      // Oracle address here
      oracle = 0x790E357227fa5936b894cBB7eb2Db8F10eddfD6b;
      // Job Id here
      jobId = "c2e769e6008c427eb215508a46eee9f3";
      fee = 1 * 10 ** 18; 
    }

    /*
    * @title createPlainPlank
    * @notice 会員証のMintとinitialURIの設定
    * @dev RobinIdはCounterを使用
    */
    function createPlainPlank() public {
      //準備
      uint256 _RobinId = _robinCounter.current();
      Rarity initialEigenVal = Rarity(0);
      tokenIdToRarity[_RobinId] = initialEigenVal;
      RobinsToSuccessors[_RobinId] = 0;
      _robinCounter.increment();

      _safeMint(_msgSender(), _RobinId);
      _setTokenURI(_RobinId, _transitionUri);
    }

    /*
    * @title createRobin
    * @notice 会員証のMintと継承
    * @dev RobinIdはCounterを使用
    */
    function createPlank() public {
      //準備
      uint256 _RobinId = _robinCounter.current();
      Rarity initialEigenVal = Rarity(0);
      tokenIdToRarity[_RobinId] = initialEigenVal;
      RobinsToSuccessors[_RobinId] = 1;
      uint256 successorId = RobinsToSuccessors[_RobinId];
      RobinsToSuccessors[_RobinId] = RobinsToSuccessors[_RobinId].add(1);
      _robinCounter.increment();

      _safeMint(_msgSender(), _RobinId);
      _setTokenURI(_RobinId, _transitionUri);
      _change(successorId, _RobinId, _msgSender());
    }

    /*
    * @title Inherit
    * @notice 会員証の継承
    * @param to 継承先のアドレス
    * @param robinId 継承する会員証のId
    * @dev ConsumerApiからprofileを取得して格納
    */
    function Inherit(
      address to,
      uint256 robinId
    ) public {
      uint256 successorId = RobinsToSuccessors[robinId];
      RobinsToSuccessors[robinId] = RobinsToSuccessors[robinId].add(1);

      _setTokenURI(robinId, _transitionUri);
      _change(successorId, robinId, to);
      transferFrom(_msgSender(), to, robinId);
    }

    /*
    * @title _change
    * @notice profileの更新
    * @param successorId 継承者数
    * @param robinId 会員証ID
    * @dev url => _setTokenURI
    *      successor => Successors
    */
    function _change(uint256 successorId, uint256 robinId, address to) private {
      toAddr[robinId] = to;
      currentRobinId = robinId;
      requestData(robinId);
      _grading(robinId, successorId);
    }

    /*
    * @title _grading
    * @notice グレードの判定
    * @dev Successor = 0~2=>STANDARD, 3~9=>EPIC, 10~=>LEGEND
    */
    function _grading(uint256 robinId, uint256 successorId) private {
      if(successorId <= 2){
        tokenIdToRarity[robinId] = Rarity.STANDARD;
      }
      else if(successorId <= 9){
        tokenIdToRarity[robinId] = Rarity.EPIC;
      }
      else {
        tokenIdToRarity[robinId] = Rarity.LEGEND;
      }
    }

    /*
    * @title requestData
    * @notice apiにデータ取得をリクエストする
    * @return requestId 
    * @dev requestの経路 DynamicRountRobin => ChainlinkClient => Oracle
    * => Job(Chainlinknode) => api
    */
    function requestData(uint256 id) public returns (bytes32 requestId) 
    {
        Chainlink.Request memory request = buildChainlinkRequest(jobId, address(this), this.multiFulfill.selector);

        strToAddr[id] = addressToString(toAddr[id]);
        request.add("get", string(abi.encodePacked(baseUrl, strToAddr[id])));
        request.add("path_image", "assets,0,image_url");
        request.add("path_address", "assets,0,owner,address");
        request.add("path_name", "assets,0,owner,user,username");

        return sendChainlinkRequestTo(oracle, request, fee);
    }

    /*
    * @title fulfill
    * @notice apiからデータを受け取ってコントラクトに格納する関数
    * @param _requestId 
    * @param _data bytes32のデータ群
    * @dev ChainlinkClientがこの関数を呼び出すことをbuildChainlinkRequest()で設定
    */
    function fulfill(bytes32 _requestId, bytes32 _data) public recordChainlinkFulfillment(_requestId)
    {
        strData = toString(_data);
    }

    /*
    * @title multiFulfill
    * @notice apiから複数データを受け取ってコントラクトに格納する関数
    * @param _requestId 
    * @param _data bytes32のデータ群
    * @dev ChainlinkClientがこの関数を呼び出すことをbuildChainlinkRequest()で設定
    */
    function multiFulfill(
      bytes32 _requestId, bytes32 _uri1, bytes32 _uri2, bytes32 _username
      ) public recordChainlinkFulfillment(_requestId){
        string memory StrUri1 = toString(_uri1);
        string memory StrUri2 = toString(_uri2);
        Successors[currentRobinId] = toString(_username);
        robinUri = string(abi.encodePacked("https://ipfs.moralis.io:2053/ipfs/", StrUri1, StrUri2));
        _setTokenURI(currentRobinId, robinUri);
    }

    /*
    * @title toString
    * @notice bytes32 => string
    * @param _bytes32 oracleから渡されるbytes32のデータ
    * @return string
    * @dev 引数はマージンが右側のByteコードのみ
    */
    function toString(bytes32 _bytes32) public pure returns (string memory) {
        uint8 i = 0;
        while(i < 32 && _bytes32[i] != 0) {
            i++;
        }
        bytes memory bytesArray = new bytes(i);
        for (i = 0; i < 32 && _bytes32[i] != 0; i++) {
            bytesArray[i] = _bytes32[i];
        }
        return string(bytesArray);
    }

    /*
    * @title addressToString
    * @notice address => string
    * @param _addr 継承先のアドレス
    * @return string apiurlに利用するアドレス文字列
    */
    function addressToString(address _addr) public pure returns(string memory) 
    {
      string memory result = Strings.toHexString(uint256(uint160(_addr)), 20);
      return result;
    }    

    function getSuccessors(uint256 robinId) public view returns(uint256){
      return RobinsToSuccessors[robinId].sub(1);
    }

    function getGrade(uint256 robinId) public view returns(Rarity){
      return tokenIdToRarity[robinId];
    }

    function getSuccessorName(uint256 robinId) public view returns(string memory){
      return Successors[robinId];
    }
}

const hre = require("hardhat");

const initialUri = "https://ipfs.moralis.io:2053/ipfs/Qme6DxdoYJLifLgv5bTNBWc23SPRY39HdxuTRVZ2to6ubF/metadata/0000000000000000000000000000000000000000000000000000000000000001.json";

async function main() {
  const factory = await hre.ethers.getContractFactory("MagicPlank");
  const MagicPlank = await factory.deploy(initialUri);
  await MagicPlank.deployed();
  console.log("NFT deployed to:", MagicPlank.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

//main.jsの実行前にDynamicRoundRobinにLINKトークン(継承あたり1link)を送ること!!

const contractAddr = "YOUR_CONTRACT_ADDRESS";

async function main() {
  const factory = await ethers.getContractFactory("MagicPlank");
  const MagicPlank = await factory.attach(contractAddr);
  console.log("NFT Deployed to:", MagicPlank.address);
  const MintTx = await MagicPlank.createPlainPlank();
  await MintTx.wait();
  await MintTx1.wait();
  const uri = await MagicPlank.tokenURI(0);
  console.log(uri);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

$ npx hardhat run scripts/deploy.js --network rinkeby

$ npx hardhat run scripts/mint.js --network rinkeby

/*
* @title _beforeTokenTransfer
* @notice OpenseaのSell連動用
* @param from 継承元のアドレス
* @param to 継承先のアドレス
* @param robinId 継承する会員証のId
* @dev Mint時には実行されない
*/
function _beforeTokenTransfer (
  address from,
  address to,
  uint256 robinId
) internal virtual override {
  if(from != address(0)){
    super._beforeTokenTransfer(from, to, robinId);
    uint256 successorId = RobinsToSuccessors[robinId];
    RobinsToSuccessors[robinId] = RobinsToSuccessors[robinId].add(1);

    _setTokenURI(robinId, _transitionUri);
    _change(successorId, robinId, to);
  }
}